init.lua

@@ -1,5 +1,21 @@
-vim.g.have_nerd_font = true
 require("keymaps")
+
+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({ { import = "plugins" }, { import = "plugins.lsp" }, { import = "plugins.themes" } })
+require("setup.lsp")
+vim.cmd("colorscheme rose-pine")
+
+
 require("options.default")
-require("lazy_bootstrap")
-require("lazy").setup({ { import = "plugins" } })

lazy-lock.json

@@ -1,30 +1,30 @@
 {
   "Comment.nvim": { "branch": "master", "commit": "0236521ea582747b58869cb72f70ccfa967d2e89" },
   "LuaSnip": { "branch": "master", "commit": "a7a4b4682c4b3e2ba82b82a4e6e5f5a0e79dec32" },
+  "bufferline.nvim": { "branch": "main", "commit": "64e2c5def50dfd6b6f14d96a45fa3d815a4a1eef" },
+  "cmp-buffer": { "branch": "main", "commit": "3022dbc9166796b644a841a02de8dd1cc1d311fa" },
+  "cmp-cmdline": { "branch": "main", "commit": "8ee981b4a91f536f52add291594e89fb6645e451" },
   "cmp-nvim-lsp": { "branch": "main", "commit": "5af77f54de1b16c34b23cba810150689a3a90312" },
   "cmp-path": { "branch": "main", "commit": "91ff86cd9c29299a64f968ebb45846c485725f23" },
   "cmp_luasnip": { "branch": "master", "commit": "05a9ab28b53f71d1aece421ef32fee2cb857a843" },
-  "conform.nvim": { "branch": "master", "commit": "0a530b31acacf10eca9f9a74b2434ece4d232ca3" },
-  "fidget.nvim": { "branch": "main", "commit": "910104a2d0a831ba8ac662cd23d3f1c685401cf6" },
-  "gitsigns.nvim": { "branch": "main", "commit": "078041e9d060a386b0c9d3a8c7a7b019a35d3fb0" },
+  "friendly-snippets": { "branch": "main", "commit": "dcd4a586439a1c81357d5b9d26319ae218cc9479" },
+  "gruvbox.nvim": { "branch": "main", "commit": "6e4027ae957cddf7b193adfaec4a8f9e03b4555f" },
   "lazy.nvim": { "branch": "main", "commit": "83493db50a434a4c5c648faf41e2ead80f96e478" },
-  "lazygit.nvim": { "branch": "main", "commit": "774dcecbd0b9b57be6c150adacb60ced79b11b23" },
-  "mason-lspconfig.nvim": { "branch": "main", "commit": "82c7cb08ddb836ad938b2708e50085f12a8825d2" },
-  "mason-tool-installer.nvim": { "branch": "main", "commit": "1212fb6082b7177dde17ea65e429e027835aeb40" },
+  "lualine.nvim": { "branch": "master", "commit": "8b56462bfb746760465264de41b4907310f113ec" },
+  "mason-lspconfig.nvim": { "branch": "main", "commit": "21d33d69a81f6351e5a5f49078b2e4f0075c8e73" },
   "mason.nvim": { "branch": "main", "commit": "3b5068f0fc565f337d67a2d315d935f574848ee7" },
-  "neo-tree.nvim": { "branch": "v3.x", "commit": "742db4e60c74e5fbcc596aaf9e7575e1342dfd09" },
-  "neodev.nvim": { "branch": "main", "commit": "84e0290f5600e8b89c0dfcafc864f45496a53400" },
-  "nui.nvim": { "branch": "main", "commit": "cbd2668414331c10039278f558630ed19b93e69b" },
+  "neo-tree.nvim": { "branch": "v3.x", "commit": "bce454018b1570153262eecab8a7546becce2274" },
+  "nui.nvim": { "branch": "main", "commit": "756c59f46057cd2d43619cd3a6d4e01b2aa60295" },
   "nvim-cmp": { "branch": "main", "commit": "04e0ca376d6abdbfc8b52180f8ea236cbfddf782" },
-  "nvim-lspconfig": { "branch": "master", "commit": "8c1831817d40925d22cd8a555296c44c02fdaaf5" },
-  "nvim-tmux-navigation": { "branch": "main", "commit": "4898c98702954439233fdaf764c39636681e2861" },
-  "nvim-treesitter": { "branch": "master", "commit": "2014f8285e306f4c8a896c7d3af53fdd599e5a4f" },
-  "nvim-web-devicons": { "branch": "master", "commit": "cb0c967c9723a76ccb1be0cc3a9a10e577d2f6ec" },
+  "nvim-lint": { "branch": "master", "commit": "e824adb9bc01647f71e55457353a68f0f37f9931" },
+  "nvim-lspconfig": { "branch": "master", "commit": "16295b79410f131c4fa7870c663b4ace6a761fb2" },
+  "nvim-treesitter": { "branch": "master", "commit": "7ff51f53b0efb6228df2e8539b51bb2e737b77f3" },
+  "nvim-web-devicons": { "branch": "master", "commit": "75df79feb02d5e0ec114e447453775d4d291ea03" },
   "plenary.nvim": { "branch": "master", "commit": "f7adfc4b3f4f91aab6caebf42b3682945fbc35be" },
-  "rose-pine": { "branch": "main", "commit": "c52167563e6aa44b5fa6fe007faa2bcac71050f0" },
-  "telescope-fzf-native.nvim": { "branch": "main", "commit": "9ef21b2e6bb6ebeaf349a0781745549bbb870d27" },
-  "telescope-ui-select.nvim": { "branch": "master", "commit": "6e51d7da30bd139a6950adf2a47fda6df9fa06d2" },
-  "telescope.nvim": { "branch": "0.1.x", "commit": "6312868392331c9c0f22725041f1ec2bef57c751" },
-  "vim-sleuth": { "branch": "master", "commit": "1cc4557420f215d02c4d2645a748a816c220e99b" },
-  "which-key.nvim": { "branch": "main", "commit": "4433e5ec9a507e5097571ed55c02ea9658fb268a" }
+  "rose-pine": { "branch": "main", "commit": "a29b09d15a9ef5cd575fbe5ae2a3cfb854876caf" },
+  "toggle-lsp-diagnostics.nvim": { "branch": "main", "commit": "4fbfb51e3902d17613be0bc03035ce26b9a8d05d" },
+  "twilight.nvim": { "branch": "main", "commit": "8b7b50c0cb2dc781b2f4262a5ddd57571556d1e4" },
+  "vim-pencil": { "branch": "master", "commit": "6d70438a8886eaf933c38a7a43a61adb0a7815ed" },
+  "which-key.nvim": { "branch": "main", "commit": "4433e5ec9a507e5097571ed55c02ea9658fb268a" },
+  "zen-mode.nvim": { "branch": "main", "commit": "78557d972b4bfbb7488e17b5703d25164ae64e6a" }
 }

lua/config/lsp/servers/eslint.lua

@@ -0,0 +1,42 @@
+local M = {}
+
+local on_attach = function(client, bufnr)
+	client.server_capabilities.documentFormattingProvider = true
+	local function buf_set_option(...)
+		vim.api.nvim_buf_set_option(bufnr, ...)
+	end
+
+	buf_set_option("omnifunc", "v:lua.vim.lsp.omnifunc")
+end
+
+M.on_attach = on_attach
+
+M.settings = {
+	codeAction = {
+		disableRuleComment = {
+			enable = true,
+			location = "separateLine",
+		},
+		showDocumentation = {
+			enable = true,
+		},
+	},
+	codeActionOnSave = {
+		enable = false,
+		mode = "all",
+	},
+	format = true,
+	nodePath = "",
+	onIgnoredFiles = "off",
+	packageManager = "npm",
+	quiet = false,
+	rulesCustomizations = {},
+	run = "onType",
+	useESLintClass = false,
+	validate = "on",
+	workingDirectory = {
+		mode = "location",
+	},
+}
+
+return M

lua/config/lsp/servers/latex.lua

@@ -0,0 +1,11 @@
+local M = {}
+
+M.settings = {
+    ltex = {
+	 language = "en",
+         additionalRules = {
+         languageModel = '~/ngrams/',
+         },
+    }
+}
+return M

lua/config/lsp/servers/lua.lua

@@ -0,0 +1,11 @@
+local M = {}
+
+M.settings = {
+Lua = {
+diagnostics = {
+	globals = {"vim"}
+}
+}
+}
+return M
+

lua/keymaps.lua

@@ -1,17 +1,17 @@
-vim.g.mapleader = " "
-vim.g.maplocalleader = " "
-local function map(mode, lhs, rhs, opts)
+function map(mode, lhs, rhs, opts)
 	local options = { noremap = true, silent = true }
 	if opts then
 		options = vim.tbl_extend("force", options, opts)
 	end
 	vim.keymap.set(mode, lhs, rhs, options)
 end
+--This code just maps vim.keymap.set() to something easier to type. Also, typing { noremap = true, silent = true } won’t be needed, because that is also implemented in the function.
+
+vim.g.mapleader = " "
 
 map("i", "jk", "<esc>") -- remap escape
-map("n", "<leader>n", ":Neotree toggle<cr>") --open Nerdtree
 
-map("n", "<left>", '<cmd>echo "Use h to move!!"<CR>')
-map("n", "<right>", '<cmd>echo "Use l to move!!"<CR>')
-map("n", "<up>", '<cmd>echo "Use k to move!!"<CR>')
-map("n", "<down>", '<cmd>echo "Use j to move!!"<CR>')
+map("n", "<leader>+", ":bNext<cr>") --switch tabs
+map("n", "<leader>n", ":Neotree toggle<cr>") --open Nerdtree
+map("n", "<leader>z", ":ZenMode<cr>") --open ZenMode (distraction-free)
+map("n", "<leader>d", ":ToggleDiag<cr>") -- toggle all diagnostics

lua/lazy_bootstrap.lua

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

lua/options/default.lua

@@ -1,39 +1,25 @@
-vim.opt.undofile = true
+vim.opt.termguicolors = true
+vim.opt.encoding = "utf-8"
+vim.opt.autowriteall = true
+
 vim.opt.number = true
--- vim.opt.relativenumber = true
-vim.opt.mouse = "a"
-vim.opt.showmode = true
-vim.opt.clipboard = "unnamedplus"
-vim.opt.breakindent = true
+
+--vim.opt.undodir = "~/.vim/undodir"
 vim.opt.undofile = true
+vim.opt.undolevels = 1000
 
--- Case-insensitive searching UNLESS \C or capital in search
-vim.opt.ignorecase = true
-vim.opt.smartcase = true
+vim.opt.updatetime = 500
 
--- Keep signcolumn on by default
-vim.opt.signcolumn = "yes"
+vim.opt.foldmethod = "expr"
+vim.opt.foldexpr = "nvim_treesitter#foldexpr()"
+--vim.foldenable = true
+vim.cmd([[ set nofoldenable]])
+vim.opt.foldcolumn = "2"
 
--- Decrease update time
-vim.opt.updatetime = 250
+-- Don't show the mode, since it's already in status line
+vim.opt.showmode = false
 
--- Decrease mapped sequence wait time
--- Displays which-key popup sooner
-vim.opt.timeoutlen = 300
-
--- Configure how new splits should be opened
-vim.opt.splitright = true
-vim.opt.splitbelow = true
-
--- Sets how neovim will display certain whitespace in the editor.
-vim.opt.list = true
-vim.opt.listchars = { tab = "» ", trail = "·", nbsp = "␣" }
-
--- Preview substitutions live, as you type!
-vim.opt.inccommand = "split"
-
--- Show which line your cursor is on
-vim.opt.cursorline = true
-
--- Minimal number of screen lines to keep above and below the cursor.
-vim.opt.scrolloff = 10
+-- Sync clipboard between OS and Neovim.
+--  Remove this option if you want your OS clipboard to remain independent.
+--  See `:help 'clipboard'`
+vim.opt.clipboard = "unnamedplus"

lua/plugins/autocompletion.lua

@@ -1,104 +0,0 @@
-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 },
-
-          -- 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 = 'nvim_lsp' },
-          { name = 'luasnip' },
-          { name = 'path' },
-        },
-      }
-    end,
-  }

lua/plugins/autoformat.lua

@@ -1,25 +0,0 @@
-return { -- Autoformat
-    'stevearc/conform.nvim',
-    opts = {
-      notify_on_error = false,
-      format_on_save = function(bufnr)
-        -- Disable "format_on_save lsp_fallback" for languages that don't
-        -- have a well standardized coding style. You can add additional
-        -- languages here or re-enable it for the disabled ones.
-        local disable_filetypes = { c = true, cpp = true }
-        return {
-          timeout_ms = 500,
-          lsp_fallback = not disable_filetypes[vim.bo[bufnr].filetype],
-        }
-      end,
-      formatters_by_ft = {
-        lua = { 'stylua' },
-        -- Conform can also run multiple formatters sequentially
-        -- python = { "isort", "black" },
-        --
-        -- You can use a sub-list to tell conform to run *until* a formatter
-        -- is found.
-        -- javascript = { { "prettierd", "prettier" } },
-      },
-    },
-  }

lua/plugins/autotag.lua

@@ -0,0 +1,6 @@
+return {
+	"https://github.com/windwp/nvim-ts-autotag",
+	config = function()
+		require('nvim-ts-autotag').setup()
+	end
+}

lua/plugins/bufferline.lua

@@ -0,0 +1,8 @@
+return {
+	"akinsho/bufferline.nvim",
+	version = "*",
+	dependencies = "nvim-tree/nvim-web-devicons",
+	config = function()
+		require("bufferline").setup({})
+	end,
+}

lua/plugins/comment.lua

@@ -1 +1,6 @@
-return { "numToStr/Comment.nvim", opts = {} }
+return	{'numToStr/Comment.nvim',
+    	opts = {
+        -- add any options here
+    	},
+    	lazy = false,
+	}

lua/plugins/completion.lua

@@ -0,0 +1,106 @@
+return {
+	"hrsh7th/cmp-nvim-lsp",
+	"hrsh7th/cmp-buffer",
+	"hrsh7th/cmp-path",
+	"hrsh7th/cmp-cmdline",
+	{
+		"L3MON4D3/LuaSnip",
+		-- follow latest release.
+		version = "v2.*", -- Replace <CurrentMajor> by the latest released major (first number of latest release)
+		-- install jsregexp (optional!).
+		build = "make install_jsregexp",
+		dependencies = { "rafamadriz/friendly-snippets" },
+	},
+	"saadparwaiz1/cmp_luasnip",
+	"rafamadriz/friendly-snippets",
+	{
+		"hrsh7th/nvim-cmp",
+		config = function()
+			vim.opt.completeopt = { "menu", "menuone", "noselect" }
+			local cmp = require("cmp")
+			local luasnip = require("luasnip")
+			local select_opts = { behavior = cmp.SelectBehavior.Select }
+
+			cmp.setup({
+				snippet = {
+					expand = function(args)
+						luasnip.lsp_expand(args.body)
+					end,
+				},
+				sources = {
+					{ name = "path" },
+					{ name = "nvim_lsp", keyword_length = 1 },
+					{ name = "buffer", keyword_length = 3 },
+					{ name = "luasnip", keyword_length = 2 },
+				},
+				window = {
+					documentation = cmp.config.window.bordered(),
+				},
+				formatting = {
+					fields = { "menu", "abbr", "kind" },
+					format = function(entry, item)
+						local menu_icon = {
+							nvim_lsp = "λ",
+							luasnip = "⋗",
+							buffer = "Ω",
+							path = "🖫",
+						}
+
+						item.menu = menu_icon[entry.source.name]
+						return item
+					end,
+				},
+				mapping = {
+					["<Up>"] = cmp.mapping.select_prev_item(select_opts),
+					["<Down>"] = cmp.mapping.select_next_item(select_opts),
+
+					["<C-p>"] = cmp.mapping.select_prev_item(select_opts),
+					["<C-n>"] = cmp.mapping.select_next_item(select_opts),
+
+					["<C-u>"] = cmp.mapping.scroll_docs(-4),
+					["<C-d>"] = cmp.mapping.scroll_docs(4),
+
+					["<C-e>"] = cmp.mapping.abort(),
+					["<C-y>"] = cmp.mapping.confirm({ select = true }),
+					["<CR>"] = cmp.mapping.confirm({ select = false }),
+
+					["<C-f>"] = cmp.mapping(function(fallback)
+						if luasnip.jumpable(1) then
+							luasnip.jump(1)
+						else
+							fallback()
+						end
+					end, { "i", "s" }),
+
+					["<C-b>"] = cmp.mapping(function(fallback)
+						if luasnip.jumpable(-1) then
+							luasnip.jump(-1)
+						else
+							fallback()
+						end
+					end, { "i", "s" }),
+
+					["<Tab>"] = cmp.mapping(function(fallback)
+						local col = vim.fn.col(".") - 1
+
+						if cmp.visible() then
+							cmp.select_next_item(select_opts)
+						elseif col == 0 or vim.fn.getline("."):sub(col, col):match("%s") then
+							fallback()
+						else
+							cmp.complete()
+						end
+					end, { "i", "s" }),
+
+					["<S-Tab>"] = cmp.mapping(function(fallback)
+						if cmp.visible() then
+							cmp.select_prev_item(select_opts)
+						else
+							fallback()
+						end
+					end, { "i", "s" }),
+				},
+			})
+		end,
+	},
+}

lua/plugins/formatting.lua

@@ -0,0 +1,38 @@
+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" },
+        css = { "prettier" },
+        html = { "prettier" },
+        json = { "prettier" },
+        yaml = { "prettier" },
+        markdown = { "prettier" },
+        graphql = { "prettier" },
+        lua = { "stylua" },
+        python = { "isort", "black" },
+      },
+      format_on_save = {
+        lsp_fallback = true,
+        async = false,
+        timeout_ms = 500,
+      },
+    })
+
+    vim.keymap.set({ "n", "v" }, "<leader>mp", function()
+      conform.format({
+        lsp_fallback = true,
+        async = false,
+        timeout_ms = 500,
+      })
+    end, { desc = "Format file or range (in visual mode)" })
+  end,
+}

lua/plugins/fuzzyfinding.lua

@@ -1,104 +0,0 @@
-return { -- Fuzzy Finder (files, lsp, etc)
-    'nvim-telescope/telescope.nvim',
-    event = 'VimEnter',
-    branch = '0.1.x',
-    dependencies = {
-      'nvim-lua/plenary.nvim',
-      { -- If encountering errors, see telescope-fzf-native README for install instructions
-        'nvim-telescope/telescope-fzf-native.nvim',
-
-        -- `build` is used to run some command when the plugin is installed/updated.
-        -- This is only run then, not every time Neovim starts up.
-        build = 'make',
-
-        -- `cond` is a condition used to determine whether this plugin should be
-        -- installed and loaded.
-        cond = function()
-          return vim.fn.executable 'make' == 1
-        end,
-      },
-      { 'nvim-telescope/telescope-ui-select.nvim' },
-
-      -- Useful for getting pretty icons, but requires a Nerd Font.
-      { 'nvim-tree/nvim-web-devicons', enabled = vim.g.have_nerd_font },
-    },
-    config = function()
-      -- Telescope is a fuzzy finder that comes with a lot of different things that
-      -- it can fuzzy find! It's more than just a "file finder", it can search
-      -- many different aspects of Neovim, your workspace, LSP, and more!
-      --
-      -- The easiest way to use telescope, is to start by doing something like:
-      --  :Telescope help_tags
-      --
-      -- After running this command, a window will open up and you're able to
-      -- type in the prompt window. You'll see a list of help_tags options and
-      -- a corresponding preview of the help.
-      --
-      -- Two important keymaps to use while in telescope are:
-      --  - Insert mode: <c-/>
-      --  - Normal mode: ?
-      --
-      -- This opens a window that shows you all of the keymaps for the current
-      -- telescope picker. This is really useful to discover what Telescope can
-      -- do as well as how to actually do it!
-
-      -- [[ Configure Telescope ]]
-      -- See `:help telescope` and `:help telescope.setup()`
-      require('telescope').setup {
-        -- You can put your default mappings / updates / etc. in here
-        --  All the info you're looking for is in `:help telescope.setup()`
-        --
-        -- defaults = {
-        --   mappings = {
-        --     i = { ['<c-enter>'] = 'to_fuzzy_refine' },
-        --   },
-        -- },
-        -- pickers = {}
-        extensions = {
-          ['ui-select'] = {
-            require('telescope.themes').get_dropdown(),
-          },
-        },
-      }
-
-      -- Enable telescope extensions, if they are installed
-      pcall(require('telescope').load_extension, 'fzf')
-      pcall(require('telescope').load_extension, 'ui-select')
-
-      -- See `:help telescope.builtin`
-      local builtin = require 'telescope.builtin'
-      vim.keymap.set('n', '<leader>sh', builtin.help_tags, { desc = '[S]earch [H]elp' })
-      vim.keymap.set('n', '<leader>sk', builtin.keymaps, { desc = '[S]earch [K]eymaps' })
-      vim.keymap.set('n', '<leader>sf', builtin.find_files, { desc = '[S]earch [F]iles' })
-      vim.keymap.set('n', '<leader>ss', builtin.builtin, { desc = '[S]earch [S]elect Telescope' })
-      vim.keymap.set('n', '<leader>sw', builtin.grep_string, { desc = '[S]earch current [W]ord' })
-      vim.keymap.set('n', '<leader>sg', builtin.live_grep, { desc = '[S]earch by [G]rep' })
-      vim.keymap.set('n', '<leader>sd', builtin.diagnostics, { desc = '[S]earch [D]iagnostics' })
-      vim.keymap.set('n', '<leader>sr', builtin.resume, { desc = '[S]earch [R]esume' })
-      vim.keymap.set('n', '<leader>s.', builtin.oldfiles, { desc = '[S]earch Recent Files ("." for repeat)' })
-      vim.keymap.set('n', '<leader><leader>', builtin.buffers, { desc = '[ ] Find existing buffers' })
-
-      -- Slightly advanced example of overriding default behavior and theme
-      vim.keymap.set('n', '<leader>/', function()
-        -- You can pass additional configuration to telescope to change theme, layout, etc.
-        builtin.current_buffer_fuzzy_find(require('telescope.themes').get_dropdown {
-          winblend = 10,
-          previewer = false,
-        })
-      end, { desc = '[/] Fuzzily search in current buffer' })
-
-      -- Also possible to pass additional configuration options.
-      --  See `:help telescope.builtin.live_grep()` for information about particular keys
-      vim.keymap.set('n', '<leader>s/', function()
-        builtin.live_grep {
-          grep_open_files = true,
-          prompt_title = 'Live Grep in Open Files',
-        }
-      end, { desc = '[S]earch [/] in Open Files' })
-
-      -- Shortcut for searching your neovim configuration files
-      vim.keymap.set('n', '<leader>sn', function()
-        builtin.find_files { cwd = vim.fn.stdpath 'config' }
-      end, { desc = '[S]earch [N]eovim files' })
-    end,
-  }

lua/plugins/gitsigns.lua

@@ -1,12 +1,6 @@
-return { -- Adds git related signs to the gutter, as well as utilities for managing changes
+return {
 	"lewis6991/gitsigns.nvim",
-	opts = {
-		signs = {
-			add = { text = "+" },
-			change = { text = "~" },
-			delete = { text = "_" },
-			topdelete = { text = "‾" },
-			changedelete = { text = "~" },
-		},
-	},
+	config = function()
+		require("gitsigns").setup()
+	end,
 }

lua/plugins/lazygit.lua

@@ -1,15 +1,16 @@
-return -- nvim v0.8.0
-{
-	"kdheepak/lazygit.nvim",
-	cmd = {
-		"LazyGit",
-		"LazyGitConfig",
-		"LazyGitCurrentFile",
-		"LazyGitFilter",
-		"LazyGitFilterCurrentFile",
-	},
-	-- optional for floating window border decoration
-	dependencies = {
-		"nvim-lua/plenary.nvim",
+return {
+	{
+		"kdheepak/lazygit.nvim",
+		cmd = {
+			"LazyGit",
+			"LazyGitConfig",
+			"LazyGitCurrentFile",
+			"LazyGitFilter",
+			"LazyGitFilterCurrentFile",
+		},
+		-- optional for floating window border decoration
+		dependencies = {
+			"nvim-lua/plenary.nvim",
+		},
 	},
 }

lua/plugins/linting.lua

@@ -0,0 +1,57 @@
+return {
+	-- 	{
+	-- 		"mfussenegger/nvim-lint",
+	-- 		event = {
+	-- 			"BufReadPre",
+	-- 			"BufNewFile",
+	-- 		},
+	--
+	-- 		config = function()
+	-- 			require("mason-tool-installer").setup({
+	-- 				ensure_installed = {
+	-- 					"prettier", -- prettier formatter
+	-- 					--	"stylua", -- lua formatter
+	-- 					"isort", -- python formatter
+	-- 					"black", -- python formatter
+	-- 					"pylint", -- python linter
+	-- 					"biome", -- js linter
+	-- 				},
+	-- 			})
+	-- 			local lint = require("lint")
+	-- 			lint.linters_by_ft = {
+	-- 				--javascript = { "eslint_d" },
+	-- 				typescript = { "biomejs" },
+	-- 				javascriptreact = { "biomejs" },
+	-- 				typescriptreact = { "biomejs" },
+	-- 				svelte = { "biomejs" },
+	-- 				python = { "pylint" },
+	-- 				--	markdown = { "marksman" },
+	-- 				lua = { "luacheck" },
+	-- 			}
+	--
+	-- 			local lint_augroup = vim.api.nvim_create_augroup("lint", { clear = true })
+	--
+	-- 			vim.api.nvim_create_autocmd({ "BufEnter", "BufWritePost", "InsertLeave" }, {
+	-- 				group = lint_augroup,
+	-- 				callback = function()
+	-- 					lint.try_lint()
+	-- 				end,
+	-- 			})
+	--
+	-- 			vim.keymap.set("n", "<leader>l", function()
+	-- 				lint.try_lint()
+	-- 			end, { desc = "Trigger linting for current file" })
+	-- 			vim.keymap.set("n", "<leader>L", function()
+	-- 				vim.diagnostic.open_float()
+	-- 			end, { desc = "Open diagnostic in pop-up" })
+	-- 		end,
+	-- 	},
+	{
+		"WhoIsSethDaniel/toggle-lsp-diagnostics.nvim",
+		config = function()
+			require("toggle_lsp_diagnostics").init({
+				start_on = true,
+			})
+		end,
+	},
+}

lua/plugins/local-highlight.lua

@@ -0,0 +1,16 @@
+return {
+	"tzachar/local-highlight.nvim",
+	config = function()
+		require("local-highlight").setup({
+			--	file_types = { "python", "cpp" }, -- If this is given only attach to this
+			-- OR attach to every filetype except:
+			disable_file_types = { "tex" },
+			--hlgroup = "Search",
+			cw_hlgroup = nil,
+			-- Whether to display highlights in INSERT mode or not
+			insert_mode = false,
+			min_match_len = 1,
+			max_match_len = math.huge,
+		})
+	end,
+}

lua/plugins/lsp.lua

@@ -1,172 +0,0 @@
-return  { -- LSP Configuration & Plugins
-    'neovim/nvim-lspconfig',
-    dependencies = {
-      -- Automatically install LSPs and related tools to stdpath for neovim
-      'williamboman/mason.nvim',
-      '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 = {} },
-
-      -- `neodev` configures Lua LSP for your Neovim config, runtime and plugins
-      -- used for completion, annotations and signatures of Neovim apis
-      { 'folke/neodev.nvim', opts = {} },
-    },
-    config = function()
-
-      --  This function gets run when an LSP attaches to a particular buffer.
-      --    That is to say, every time a new file is opened that is associated with
-      --    an lsp (for example, opening `main.rs` is associated with `rust_analyzer`) this
-      --    function will be executed to configure the current buffer
-      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
-          -- many times.
-          --
-          -- 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)
-            vim.keymap.set('n', 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')
-
-          -- 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 whole 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', vim.lsp.buf.rename, '[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')
-
-          -- Opens a popup that displays documentation about the word under your cursor
-          --  See `:help K` for why this keymap
-          map('K', vim.lsp.buf.hover, 'Hover Documentation')
-
-          -- 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')
-
-          -- 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.server_capabilities.documentHighlightProvider then
-            vim.api.nvim_create_autocmd({ 'CursorHold', 'CursorHoldI' }, {
-              buffer = event.buf,
-              callback = vim.lsp.buf.document_highlight,
-            })
-
-            vim.api.nvim_create_autocmd({ 'CursorMoved', 'CursorMovedI' }, {
-              buffer = event.buf,
-              callback = vim.lsp.buf.clear_references,
-            })
-          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())
-
-      -- 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 = {},
-        --
-
-        lua_ls = {
-          -- cmd = {...},
-          -- filetypes { ...},
-          -- capabilities = {},
-          settings = {
-            Lua = {
-              completion = {
-                callSnippet = 'Replace',
-              },
-              -- 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,
-        },
-      }
-    end,
-  }

lua/plugins/lsp/install.lua

@@ -0,0 +1,12 @@
+return {
+	{
+		"williamboman/mason.nvim",
+		dependencies = { "WhoIsSethDaniel/mason-tool-installer.nvim" },
+	},
+	{
+		"williamboman/mason-lspconfig.nvim",
+	},
+	{
+		"neovim/nvim-lspconfig",
+	},
+}

lua/plugins/lualine.lua

@@ -0,0 +1,16 @@
+return {
+	"nvim-lualine/lualine.nvim",
+	dependencies = {
+		"nvim-tree/nvim-web-devicons",
+	},
+	config = function()
+		local function getWords()
+			return tostring(vim.fn.wordcount().words)
+		end
+		require("lualine").setup({
+			sections = {
+				lualine_z = { getWords },
+			},
+		})
+	end,
+}

lua/plugins/neotree.lua

@@ -1,12 +1,21 @@
 return {
-{
-    "nvim-neo-tree/neo-tree.nvim",
-    branch = "v3.x",
-    dependencies = {
-      "nvim-lua/plenary.nvim",
-      "nvim-tree/nvim-web-devicons", -- not strictly required, but recommended
-      "MunifTanjim/nui.nvim",
-      -- "3rd/image.nvim", -- Optional image support in preview window: See `# Preview Mode` for more information
-    }
-}
+	"nvim-neo-tree/neo-tree.nvim",
+	branch = "v3.x",
+	dependencies = {
+		"nvim-lua/plenary.nvim",
+		"nvim-tree/nvim-web-devicons", -- not strictly required, but recommended
+		"MunifTanjim/nui.nvim",
+		-- "3rd/image.nvim", -- Optional image support in preview window: See `# Preview Mode` for more information
+	},
+	config = function()
+		require("neo-tree").setup({
+			filesystem = {
+				filtered_items = {
+					visible = true, -- This is what you want: If you set this to `true`, all "hide" just mean "dimmed out"
+					hide_dotfiles = false,
+					hide_gitignored = true,
+				},
+			},
+		})
+	end,
 }

lua/plugins/rainbow-delimiters.lua

@@ -0,0 +1,23 @@
+return {
+"https://gitlab.com/HiPhish/rainbow-delimiters.nvim",
+config = function()
+require('rainbow-delimiters.setup').setup {
+    -- strategy = {
+    --     -- ...
+    -- },
+    -- query = {
+    --     -- ...
+    -- },
+    highlight = {
+	'RainbowDelimiterYellow',
+        'RainbowDelimiterBlue',
+        'RainbowDelimiterOrange',
+        'RainbowDelimiterGreen',
+        'RainbowDelimiterViolet',
+        'RainbowDelimiterCyan',
+
+    },
+}
+
+end
+}

lua/plugins/sleuth.lua

@@ -1,3 +0,0 @@
-return {
-	"tpope/vim-sleuth", -- Detect tabstop and shiftwidth automatically
-}

lua/plugins/surround.lua

@@ -0,0 +1,10 @@
+return {
+	"kylechui/nvim-surround",
+	version = "*", -- Use for stability; omit to use `main` branch for the latest features
+	event = "VeryLazy",
+	config = function()
+		require("nvim-surround").setup({
+			-- Configuration here, or leave empty to use defaults
+		})
+	end,
+}

lua/plugins/telescope.lua

@@ -0,0 +1,12 @@
+return {
+	"nvim-telescope/telescope.nvim",
+	tag = "0.1.6",
+	dependencies = { "nvim-lua/plenary.nvim" },
+	opts = {
+		extensions = {
+			thesaurus = {
+				provider = "freedictionaryapi",
+			},
+		},
+	},
+}

lua/plugins/themes.lua

@@ -1,11 +0,0 @@
-return {
-	"rose-pine/neovim",
-	name = "rose-pine",
-	priority = 1000,
-	init = function()
-		-- Load the colorscheme here.
-		-- Like many other themes, this one has different styles, and you could load
-		-- any other, such as 'tokyonight-storm', 'tokyonight-moon', or 'tokyonight-day'.
-		vim.cmd.colorscheme("rose-pine-main")
-	end,
-}

lua/plugins/themes/gruvbox.lua

@@ -0,0 +1 @@
+return	{ "ellisonleao/gruvbox.nvim", priority = 1000 , config = true, opts = ...}

lua/plugins/themes/papercolor.lua

@@ -0,0 +1,3 @@
+return {
+	"NLKNguyen/papercolor-theme",
+}

lua/plugins/themes/rose-pine.lua

@@ -0,0 +1,2 @@
+
+return {"rose-pine/neovim", name = "rose-pine"}

lua/plugins/themes/solarized.lua

@@ -0,0 +1,3 @@
+return {
+	"maxmx03/solarized.nvim",
+}

lua/plugins/thesaurus.lua

@@ -0,0 +1,6 @@
+return {
+	{
+		"nvim-telescope/telescope.nvim",
+		dependencies = { "rafi/telescope-thesaurus.nvim" },
+	},
+}

lua/plugins/tmux-navigation.lua

@@ -0,0 +1,19 @@
+return {
+	{
+		"alexghergh/nvim-tmux-navigation",
+		config = function()
+			local nvim_tmux_nav = require("nvim-tmux-navigation")
+
+			nvim_tmux_nav.setup({
+				disable_when_zoomed = true, -- defaults to false
+			})
+
+			vim.keymap.set("n", "<C-h>", nvim_tmux_nav.NvimTmuxNavigateLeft)
+			vim.keymap.set("n", "<C-j>", nvim_tmux_nav.NvimTmuxNavigateDown)
+			vim.keymap.set("n", "<C-k>", nvim_tmux_nav.NvimTmuxNavigateUp)
+			vim.keymap.set("n", "<C-l>", nvim_tmux_nav.NvimTmuxNavigateRight)
+			vim.keymap.set("n", "<C-\\>", nvim_tmux_nav.NvimTmuxNavigateLastActive)
+			vim.keymap.set("n", "<C-Space>", nvim_tmux_nav.NvimTmuxNavigateNext)
+		end,
+	},
+}

lua/plugins/tmux_navigation.lua

@@ -1,16 +0,0 @@
-return {
-	"alexghergh/nvim-tmux-navigation",
-	config = function()
-		require("nvim-tmux-navigation").setup({
-			disable_when_zoomed = true, -- defaults to false
-			keybindings = {
-				left = "<C-h>",
-				down = "<C-j>",
-				up = "<C-k>",
-				right = "<C-l>",
-				last_active = "<C-\\>",
-				next = "<C-Space>",
-			},
-		})
-	end,
-}

lua/plugins/transparent.lua

@@ -0,0 +1 @@
+return { "xiyaowong/transparent.nvim" }

lua/plugins/treesitter.lua

@@ -1,30 +1,3 @@
-return { -- Highlight, edit, and navigate code
-    'nvim-treesitter/nvim-treesitter',
-    build = ':TSUpdate',
-    opts = {
-      ensure_installed = { 'bash', 'c', 'html', 'lua', 'markdown', 'vim', 'vimdoc' },
-      -- Autoinstall languages that are not installed
-      auto_install = true,
-      highlight = {
-        enable = true,
-        -- Some languages depend on vim's regex highlighting system (such as Ruby) for indent rules.
-        --  If you are experiencing weird indenting issues, add the language to
-        --  the list of additional_vim_regex_highlighting and disabled languages for indent.
-        additional_vim_regex_highlighting = { 'ruby' },
-      },
-      indent = { enable = true, disable = { 'ruby' } },
-    },
-    config = function(_, opts)
-      -- [[ Configure Treesitter ]] See `:help nvim-treesitter`
-
-      ---@diagnostic disable-next-line: missing-fields
-      require('nvim-treesitter.configs').setup(opts)
-
-      -- There are additional nvim-treesitter modules that you can use to interact
-      -- with nvim-treesitter. You should go explore a few and see what interests you:
-      --
-      --    - Incremental selection: Included, see `:help nvim-treesitter-incremental-selection-mod`
-      --    - Show your current context: https://github.com/nvim-treesitter/nvim-treesitter-context
-      --    - Treesitter + textobjects: https://github.com/nvim-treesitter/nvim-treesitter-textobjects
-    end,
-  }
+return	{
+	"nvim-treesitter/nvim-treesitter"
+	}

lua/plugins/twilight.lua

@@ -0,0 +1 @@
+return {"folke/twilight.nvim", opts = {context = 1}}

lua/plugins/vim-pencil.lua

@@ -0,0 +1 @@
+return {"preservim/vim-pencil"}

lua/plugins/which-key.lua

@@ -0,0 +1,12 @@
+return {"folke/which-key.nvim",
+  		event = "VeryLazy",
+  		init = function()
+    			vim.o.timeout = true
+    			vim.o.timeoutlen = 300
+  		end,
+  		opts = {
+    		-- your configuration comes here
+    		-- or leave it empty to use the default settings
+    		-- refer to the configuration section below
+		}
+  	}

lua/plugins/whichkey.lua

@@ -1,16 +0,0 @@
-return { -- Useful plugin to show you pending keybinds.
-    'folke/which-key.nvim',
-    event = 'VimEnter', -- Sets the loading event to 'VimEnter'
-    config = function() -- This is the function that runs, AFTER loading
-      require('which-key').setup()
-
-      -- Document existing key chains
-      require('which-key').register {
-        ['<leader>c'] = { name = '[C]ode', _ = 'which_key_ignore' },
-        ['<leader>d'] = { name = '[D]ocument', _ = 'which_key_ignore' },
-        ['<leader>r'] = { name = '[R]ename', _ = 'which_key_ignore' },
-        ['<leader>s'] = { name = '[S]earch', _ = 'which_key_ignore' },
-        ['<leader>w'] = { name = '[W]orkspace', _ = 'which_key_ignore' },
-      }
-    end,
-  }

lua/plugins/zen-mode.lua

@@ -0,0 +1,4 @@
+return {"folke/zen-mode.nvim",
+		opts = {
+		window = {width = 60}}
+	}

lua/setup/lsp.lua

@@ -0,0 +1,117 @@
+local lsp_capabilities = require("cmp_nvim_lsp").default_capabilities()
+
+local default_setup = function(server)
+	require("lspconfig")[server].setup({
+		capabilities = lsp_capabilities,
+	})
+end
+
+-- enable mason and configure icons
+require("mason").setup({
+	ui = {
+		icons = {
+			package_installed = "✓",
+			package_pending = "➜",
+			package_uninstalled = "✗",
+		},
+	},
+})
+
+require("mason-lspconfig").setup({
+	ensure_installed = {
+		--		"tsserver",
+		"cssls",
+		"html",
+		"bashls",
+		"eslint",
+		"ltex",
+		--"marksman",
+		--"lua_ls" has to be installed via package manager on ARM systems
+	},
+	handlers = {
+		default_setup,
+	},
+})
+
+local on_attach = function()
+	vim.api.nvim_create_autocmd("LspAttach", {
+		desc = "LSP actions",
+		callback = function()
+			local bufmap = function(mode, lhs, rhs)
+				local opts = { buffer = true }
+				vim.keymap.set(mode, lhs, rhs, opts)
+			end
+
+			-- Displays hover information about the symbol under the cursor
+			bufmap("n", "K", "<cmd>lua vim.lsp.buf.hover()<cr>")
+
+			-- Jump to the definition
+			bufmap("n", "gd", "<cmd>lua vim.lsp.buf.definition()<cr>")
+
+			-- Jump to declaration
+			bufmap("n", "gD", "<cmd>lua vim.lsp.buf.declaration()<cr>")
+
+			-- Lists all the implementations for the symbol under the cursor
+			bufmap("n", "gi", "<cmd>lua vim.lsp.buf.implementation()<cr>")
+
+			-- Jumps to the definition of the type symbol
+			bufmap("n", "go", "<cmd>lua vim.lsp.buf.type_definition()<cr>")
+
+			-- Lists all the references
+			bufmap("n", "gr", "<cmd>lua vim.lsp.buf.references()<cr>")
+
+			-- Displays a function's signature information
+			bufmap("n", "gs", "<cmd>lua vim.lsp.buf.signature_help()<cr>")
+
+			-- Renames all references to the symbol under the cursor
+			bufmap("n", "<F2>", "<cmd>lua vim.lsp.buf.rename()<cr>")
+
+			-- Selects a code action available at the current cursor position
+			bufmap("n", "<F4>", "<cmd>lua vim.lsp.buf.code_action()<cr>")
+
+			-- Show diagnostics in a floating window
+			bufmap("n", "gl", "<cmd>lua vim.diagnostic.open_float()<cr>")
+
+			-- Move to the previous diagnostic
+			bufmap("n", "nd", "<cmd>lua vim.diagnostic.goto_prev()<cr>")
+
+			-- Move to the next diagnostic
+			bufmap("n", "nd", "<cmd>lua vim.diagnostic.goto_next()<cr>")
+		end,
+	})
+end
+
+local lspconfig = require("lspconfig")
+
+require("mason-lspconfig").setup_handlers({
+	-- The first entry (without a key) will be the default handler
+	-- and will be called for each installed server that doesn't have
+	-- a dedicated handler.
+	function(server_name)
+		require("lspconfig")[server_name].setup({
+			on_attach = on_attach,
+			capabilities = lsp_capabilities,
+		})
+	end,
+	-- ["eslint"] = function()
+	-- 	lspconfig.eslint.setup({
+	-- 		capabilities = lsp_capabilities,
+	-- 		on_attach = require("config.lsp.servers.eslint").on_attach,
+	-- 		settings = require("config.lsp.servers.eslint").settings,
+	-- 	})
+	-- end,
+	["lua_ls"] = function()
+		lspconfig.lua_ls.setup({
+			capabilities = lsp_capabilities,
+			on_attach = on_attach,
+			settings = require("config.lsp.servers.lua").settings,
+		})
+	end,
+	["ltex"] = function()
+		lspconfig.ltex.setup({
+			capabilities = lsp_capabilities,
+			on_attach = on_attach,
+			settings = require("config.lsp.servers.latex").settings,
+		})
+	end,
+})

package.json

@@ -0,0 +1,5 @@
+{
+  "dependencies": {
+    "eslint": "^8.57.0"
+  }
+}