Resort files into different directories

31 files changed, 4075 insertions, 0 deletions

diff --git a/lua/plugins/autopairs.lua b/lua/plugins/autopairs.lua
new file mode 100644
index 0000000..fc39d2e
--- /dev/null
+++ b/lua/plugins/autopairs.lua
@@ -0,0 +1,43 @@
+-- Setup nvim-cmp.
+local status_ok, npairs = pcall(require, "nvim-autopairs")
+if not status_ok then
+  return
+end
+
+npairs.setup {
+  check_ts = true,
+  ts_config = {
+    lua = { "string", "source" },
+    javascript = { "string", "template_string" },
+    java = false,
+  },
+    map = "<M-e>",
+    pairs_map = {
+['<'] = '>',
+},
+  disable_filetype = { "TelescopePrompt", "spectre_panel" },
+  disable_in_macro = true,
+  disable_in_visualblock = true,
+  enalbe_moveright = true,
+  enable_afterquote = true,  -- add bracket pairs after quote
+  enable_check_bracket_line = true,  --- check bracket in same line
+  enable_bracket_in_quote = true, --
+  break_undo = true, -- switch for basic rule break undo sequence
+  fast_wrap = {
+    chars = { "{", "[", "(", '"', "'" },
+    pattern = string.gsub([[ [%'%"%)%>%]%)%}%,] ]], "%s+", ""),
+    offset = 0, -- Offset from pattern match
+    end_key = "$",
+    keys = "qwertyuiopzxcvbnmasdfghjkl",
+    check_comma = true,
+    highlight = "PmenuSel",
+    highlight_grey = "LineNr",
+  },
+}
+
+local cmp_autopairs = require "nvim-autopairs.completion.cmp"
+local cmp_status_ok, cmp = pcall(require, "cmp")
+if not cmp_status_ok then
+  return
+end
+cmp.event:on("confirm_done", cmp_autopairs.on_confirm_done { map_char = { tex = "" } })
diff --git a/lua/plugins/cmp-gh-source.lua b/lua/plugins/cmp-gh-source.lua
new file mode 100644
index 0000000..05bba55
--- /dev/null
+++ b/lua/plugins/cmp-gh-source.lua
@@ -0,0 +1,72 @@
+local ok, Job = pcall(require, "plenary.job")
+if not ok then
+  return
+end
+
+local source = {}
+
+source.new = function()
+  local self = setmetatable({ cache = {} }, { __index = source })
+
+  return self
+end
+
+source.complete = function(self, _, callback)
+  local bufnr = vim.api.nvim_get_current_buf()
+
+  -- This just makes sure that we only hit the GH API once per session.
+  --
+  -- You could remove this if you wanted, but this just makes it so we're
+  -- good programming citizens.
+  if not self.cache[bufnr] then
+    Job
+      :new({
+        -- Uses `gh` executable to request the issues from the remote repository.
+        "gh",
+        "issue",
+        "list",
+        "--limit",
+        "1000",
+        "--json",
+        "title,number,body",
+
+        on_exit = function(job)
+          local result = job:result()
+          local ok, parsed = pcall(vim.json.decode, table.concat(result, ""))
+          if not ok then
+            vim.notify "Failed to parse gh result"
+            return
+          end
+
+          local items = {}
+          for _, gh_item in ipairs(parsed) do
+            gh_item.body = string.gsub(gh_item.body or "", "\r", "")
+
+            table.insert(items, {
+              label = string.format("#%s", gh_item.number),
+              documentation = {
+                kind = "markdown",
+                value = string.format("# %s\n\n%s", gh_item.title, gh_item.body),
+              },
+            })
+          end
+
+          callback { items = items, isIncomplete = false }
+          self.cache[bufnr] = items
+        end,
+      })
+      :start()
+  else
+    callback { items = self.cache[bufnr], isIncomplete = false }
+  end
+end
+
+source.get_trigger_characters = function()
+  return { "#" }
+end
+
+source.is_available = function()
+  return vim.bo.filetype == "gitcommit"
+end
+
+require("cmp").register_source("gh_issues", source.new())
diff --git a/lua/plugins/cmp.lua b/lua/plugins/cmp.lua
new file mode 100644
index 0000000..1ef2580
--- /dev/null
+++ b/lua/plugins/cmp.lua
@@ -0,0 +1,319 @@
+
+-- Setup nvim-cmp.
+vim.opt.completeopt = "menu,menuone,noselect"
+--vim.g.completeopt = "menu,menuone,noselect,noinsert"
+local cmp_status_ok, cmp = pcall(require, "cmp")
+if not cmp_status_ok then
+	return
+end
+--local WIDE_HEIGHT = 40
+
+local opts = {
+	-- whether to highlight the currently hovered symbol
+	-- disable if your cpu usage is higher than you want it
+	-- or you just hate the highlight
+	-- default: true
+	highlight_hovered_item = true,
+	show_guides = true,
+}
+require("symbols-outline").setup(opts)
+
+
+--local snippets_paths = function()
+--	local plugins = { "friendly-snippets" }
+--	local paths = {}
+--	local path
+--	local root_path = vim.env.HOME .. "/.vim/plugged/"
+--	for _, plug in ipairs(plugins) do
+--		path = root_path .. plug
+--		if vim.fn.isdirectory(path) ~= 0 then
+--			table.insert(paths, path)
+--		end
+--	end
+--	return paths
+--end
+--
+--require("luasnip.loaders.from_vscode").lazy_load({
+--	paths = snippets_paths(),
+--	include = nil, -- Load all languages
+--	exclude = {},
+--})
+
+--require("luasnip.loaders.from_vscode").lazy_load()
+local lspkind = require("lspkind")
+local kind_icons = {
+  Text = "",
+  Method = "m", --"",
+  Function = "",
+  Constructor = "", --"⚙️",
+  Field = "",
+  Variable = "",
+  Class = "",
+  Interface = "",
+  Module = "",
+  Property = "",
+  Unit = "",
+  Value = "",
+  Enum = "",
+  Keyword = "",
+  Snippet = "",
+  Color = "",
+  File = "",
+  Reference = "",
+  Folder = "",
+  EnumMember = "",
+  Constant = "",
+  Struct = "",
+  Event = "",
+  Operator = "",
+  TypeParameter = "",
+}
+cmp.setup({
+	snippet = {
+		--expand = function(args)
+		--	require("luasnip").lsp_expand(args.body)
+		--end,
+    expand = function(args)
+      local luasnip = require("luasnip")
+      if not luasnip then
+          return
+      end
+      luasnip.lsp_expand(args.body)
+    end,
+	},
+	mapping = cmp.mapping.preset.insert({
+--		["<CR>"] = cmp.mapping.confirm({
+--			behavior = cmp.ConfirmBehavior.Replace,
+--			select = true,
+--		}),
+    --["<C-k>"] = cmp.mapping(cmp.mapping.select_prev_item(), { 'i', 'c' }),
+    --["<C-j>"] = cmp.mapping(cmp.mapping.select_next_item(), { 'i', 'c' }),
+    ['<C-y>'] = cmp.mapping.confirm({ select = true }),
+		--["<C-e>"] = cmp.mapping.close(),
+    --['<C-e>'] = cmp.mapping({
+    --  i = cmp.mapping.abort(),
+    --  c = cmp.mapping.close(),
+    --}),
+    ["<C-e>"] = cmp.mapping({
+      i = function()
+        if cmp.visible() then
+          cmp.abort()
+          require("user.utils").toggle_completion()
+          require("notify")("completion off")
+        else
+          cmp.complete()
+          require("user.utils").toggle_completion()
+          require("notify")("completion on")
+        end
+      end,
+    }),
+    --["<CR>"] = cmp.mapping({
+    --  i = function(fallback)
+    --    if cmp.visible() then
+    --      cmp.confirm({ behavior = cmp.ConfirmBehavior.Replace, select = false })
+    --      require("user.utils").toggle_completion()
+    --    else
+    --      fallback()
+    --    end
+    --  end,
+    --}),
+
+--      ["<C-e>"] = cmp.mapping({
+--    i = function()
+--      if cmp.visible() then
+--        require("notify")("visible")
+--        cmp.abort()
+--      else
+--        require("notify")("not visible")
+--        cmp.complete()
+--      end
+--    end,
+--    c = function()
+--      if cmp.visible() then
+--        require("notify")("visible")
+--        cmp.close()
+--      else
+--        require("notify")("not visible")
+--        cmp.complete()
+--      end
+--    end,
+--  }),
+    --['<CR>'] = cmp.config.disable,
+		["<C-u>"] = cmp.mapping.scroll_docs(-4),
+		["<C-d>"] = cmp.mapping.scroll_docs(4),
+		["<C-Space>"] = cmp.mapping.complete(),
+    --['<C-o>'] = function(fallback)
+    --  if cmp.visible() then
+    --    cmp.mapping.confirm({ select = true })(fallback)
+    --  else
+    --    cmp.mapping.complete()(fallback)
+    --  end
+    --end
+	}),
+
+  sources = cmp.config.sources({
+		--{ name = "nvim_lua" },
+    { name = "luasnip" },
+		--{ name = 'luasnip', option = { use_show_condition = false } },
+		{ name = "gh_issues" },
+		{ name = "nvim_lsp", max_item_count = 6 },
+    { name = "nvim_lua" },
+		--{ name = "luasnip" },
+		--{ name = "luasnip", keyword_length = 4 },
+		--{ name = "buffer", keyword_length = 3 },
+		{ name = "path" },
+    { name = "buffer", max_item_count = 6 },
+    --{ name = "buffer", option = { get_bufnrs = function()
+    --  return vim.api.nvim_list_bufs()
+    --end
+    --}},
+    { name = "cmp_git"},
+    --{ name = 'treesitter' },
+		--{ name = "cmdline", keyword_pattern = [=[[^[:blank:]\!]*]=] }, --exclamation mark hangs a bit without this
+		--{name = 'luasnip', keyword_length = 2},
+	}),
+	formatting = {
+      --formatting = {
+      --local icons = kind_icons
+        --format = function(entry, vim_item)
+        ----vim_item.kind = string.format("%s", kind_icons[vim_item.kind])
+        ----vim_item.kind = lspkind.presets.default[vim_item.kind]
+        --vim_item.kind = string.format('%s %s', kind_icons[vim_item.kind], vim_item.kind) -- This concatonates the icons with the name of the item kind
+        ----vim_item.kind = string.format("%s %s", icons[vim_item.kind], vim_item.kind)
+        --vim_item.menu = ({
+				----nvim_lsp = "LSP",
+				----luasnip = "snip",
+				----buffer = "buf",
+				----path = "path",
+        ----cmdline = "cmd",
+        --buffer = "[buf]",
+        --nvim_lsp = "[LSP]",
+        --nvim_lua = "[api]",
+        --path = "[path]",
+        --luasnip = "[snip]",
+        --cmdline = "[cmd]",
+        --gh_issues = "[issues]",
+        --})[entry.source.name]
+        --return vim_item
+        --end,
+    format = lspkind.cmp_format {
+      with_text = true,
+      menu = {
+        nvim_lsp = "[LSP]",
+        luasnip = "[snip]",
+        buffer = "[buf]",
+        nvim_lua = "[api]",
+        path = "[path]",
+        gh_issues = "[issues]",
+      },
+    },
+  --},
+
+    --
+    --
+		--fields = { "abbr", "kind", "menu" },
+   --    format = lspkind.cmp_format({
+   --   mode = 'symbol_text', -- show only symbol annotations
+   --   maxwidth = 50, -- prevent the popup from showing more than provided characters (e.g 50 will not show more than 50 characters)
+   -- })
+    --format = require('lspkind').cmp_format {
+    --  with_text = true,
+    --  menu = {
+    --    luasnip = "Snip",
+    --    buffer = "Buf",
+    --    nvim_lsp = "LSP",
+    --    path = "Path",
+    --    cmdline = "Cmd",
+    --    cmp_git = "Git",
+    --  },
+    --},
+  },
+		--format = function(entry, vim_item)
+		--	-- Kind icons
+		--	--vim_item.kind = string.format("%s", kind_icons[vim_item.kind])
+    --  vim_item.kind = lspkind.presets.default[vim_item.kind]
+		--	-- vim_item.kind = string.format('%s %s', kind_icons[vim_item.kind], vim_item.kind) -- This concatonates the icons with the name of the item kind
+		--	vim_item.menu = ({
+		--		nvim_lsp = "LSP",
+		--		luasnip = "Snip",
+		--		buffer = "Buf",
+		--		path = "Path",
+    --    cmdline = "Cmd",
+		--	})[entry.source.name]
+		--	return vim_item
+		--end,
+  confirm_opts = {
+		behavior = cmp.ConfirmBehavior.Replace,
+		select = false,
+	},
+
+
+  event = {},
+
+    experimental = {
+      ghost_text = true,
+      hl_group = 'Nontext',
+      --native_menu = false,
+    },
+
+    view = {
+      entries = { name = 'custom', selection_order = 'top_down' },
+    },
+
+    window = {
+      --completion = cmp.config.window.bordered(),
+      completion = {
+        border = { '', '', '', ' ', '', '', '', ' ' },
+        --border = { "╭", "─", "╮", "│", "╯", "─", "╰", "│" },
+        --border = { '', '', '', '', '', '', '', '' },
+        --border = "CmpBorder",
+        winhighlight = 'Normal:Pmenu,FloatBorder:Pmenu,CursorLine:PmenuSel,Search:None',
+        --winhighlight = "Normal:CmpPmenu,CursorLine:PmenuSel,Search:None",
+      },
+      --documentation = cmp.config.window.bordered(),
+      documentation = {
+        --max_height = math.floor(WIDE_HEIGHT * (WIDE_HEIGHT / vim.o.lines)),
+        --max_width = math.floor((WIDE_HEIGHT * 2) * (vim.o.columns / (WIDE_HEIGHT * 2 * 16 / 9))),
+        border = { '', '', '', ' ', '', '', '', ' ' },
+        --border = { "╭", "─", "╮", "│", "╯", "─", "╰", "│" },
+        winhighlight = 'FloatBorder:NormalFloat',
+      },
+    },
+})
+
+
+cmp.setup.cmdline({ '/', '?' }, {
+    mapping = cmp.mapping.preset.cmdline(),
+	sources = {
+		{ name = "buffer" },
+  },
+})
+
+cmp.setup.cmdline(":", {
+  mapping = {
+    ["<C-p>"] = cmp.mapping(cmp.mapping.select_prev_item(), { 'i', 'c' }),
+    ["<C-n>"] = cmp.mapping(cmp.mapping.select_next_item(), { 'i', 'c' }),
+    ["<C-y>"] = cmp.mapping(cmp.mapping.confirm({ select = true }), { 'i', 'c' }),
+    ["<C-e>"] = cmp.mapping(cmp.mapping.close(), { 'i', 'c' }),
+    ["<C-u>"] = cmp.mapping(cmp.mapping.scroll_docs(-4), { 'i', 'c' }),
+    ["<C-d>"] = cmp.mapping(cmp.mapping.scroll_docs(4), { 'i', 'c' }),
+    ["<C-Space>"] = cmp.mapping(cmp.mapping.complete(), { 'i', 'c' }),
+    --["<C-k>"] = cmp.mapping.select_prev_item(),
+    --["<C-j>"] = cmp.mapping.select_next_item(),
+    --['<C-y>'] = cmp.mapping.confirm({ select = true }),
+		--["<C-e>"] = cmp.mapping.close(),
+    ----['<CR>'] = cmp.config.disable,
+		--["<C-u>"] = cmp.mapping.scroll_docs(-4),
+		--["<C-d>"] = cmp.mapping.scroll_docs(4),
+		--["<C-Space>"] = cmp.mapping.complete(),
+  },
+
+	sources = cmp.config.sources({
+		{ name = "path" },
+	}, {
+		--{ name = "cmdline" },
+    { name = "cmdline", keyword_pattern = [=[[^[:blank:]\!]*]=], keyword_length = 3 },
+  })
+})
+
+
diff --git a/lua/plugins/colorizer.lua b/lua/plugins/colorizer.lua
new file mode 100644
index 0000000..14d25e2
--- /dev/null
+++ b/lua/plugins/colorizer.lua
@@ -0,0 +1,6 @@
+local status, colorizer = pcall(require, "colorizer")
+if (not status) then return end
+
+colorizer.setup({
+  '*';
+})
diff --git a/lua/plugins/colorscheme.lua b/lua/plugins/colorscheme.lua
new file mode 100644
index 0000000..3ded54c
--- /dev/null
+++ b/lua/plugins/colorscheme.lua
@@ -0,0 +1,33 @@
+-- Colorscheme
+-- ayu gruvbox molokai onedark srcery everblush vscode edge nightfly doom-one
+local colorscheme = "doom-one"
+local status_ok, _ = pcall(vim.cmd, "colorscheme " .. colorscheme)
+if not status_ok then
+	vim.notify("colorscheme " .. colorscheme .. " not found!")
+	return
+end
+
+vim.api.nvim_command("syntax on")
+vim.api.nvim_command("highlight Normal guibg=none")
+vim.api.nvim_command("highlight SignColumn guibg=none")
+vim.api.nvim_command("highlight TabLine guibg=#333842 gui=bold")
+--vim.api.nvim_command("highlight TabLine guibg=none gui=bold")
+--vim.api.nvim_command("highlight StatusLine guibg=#333842 gui=bold")
+--vim.api.nvim_command("highlight StatusLine guibg=#333842 guifg=#d6d3ea gui=bold")
+--vim.api.nvim_command("highlight StatusLine guibg=none gui=bold")
+--vim.api.nvim_command("highlight TabLineNC guibg=none gui=bold")
+--vim.api.nvim_command("highlight TabLineSel guibg=#bd93f9 gui=bold")
+vim.api.nvim_command("highlight TabLineSel guibg=#333842 gui=bold")
+vim.api.nvim_command("highlight TabLineFill guibg=none gui=bold")
+vim.api.nvim_command("highlight WinBar guibg=none gui=bold")
+vim.api.nvim_command("highlight NormalFloat guibg=none")
+vim.api.nvim_command("highlight MsgSeparator guibg=none")
+--vim.api.nvim_command("highlight PmenuSel guibg=none")
+--vim.api.nvim_command("highlight winblend guibg=none")
+--vim.api.nvim_command("highlight StatusLine guibg=none gui=bold")
+--vim.api.nvim_command("highlight StatusLineNC guibg=none gui=bold")
+--vim.api.nvim_command("highlight StatusLineNC guibg=none ctermfg=Cyan guifg=#80a0ff gui=bold")
+
+require("notify").setup({
+	background_colour = "#000000",
+})
diff --git a/lua/plugins/git.lua b/lua/plugins/git.lua
new file mode 100644
index 0000000..963f7f9
--- /dev/null
+++ b/lua/plugins/git.lua
@@ -0,0 +1,11 @@
+local status, git = pcall(require, "git")
+if (not status) then return end
+
+git.setup({
+  keymaps = {
+    -- Open blame window
+    blame = "<Leader>gb",
+    -- Open file/folder in git repository
+    browse = "<Leader>go",
+  }
+})
diff --git a/lua/plugins/gitsigns.lua b/lua/plugins/gitsigns.lua
new file mode 100644
index 0000000..53d1a1e
--- /dev/null
+++ b/lua/plugins/gitsigns.lua
@@ -0,0 +1 @@
+require('gitsigns').setup {}
diff --git a/lua/plugins/heirline.lua b/lua/plugins/heirline.lua
new file mode 100644
index 0000000..f17f523
--- /dev/null
+++ b/lua/plugins/heirline.lua
@@ -0,0 +1,1203 @@
+local conditions = require("heirline.conditions")
+local utils = require("heirline.utils")
+
+local colors = {
+	--bg = "#23232e",
+	bg = nil,
+	nobg = nil,
+	white = "#f8f8f2",
+  black = "#000000",
+	darkgray = "#23232e",
+	gray = "#2d2b3a",
+	lightgray = "#d6d3ea",
+	pink = "#f92672",
+	green = "#50fa7b",
+	blue = "#39BAE6",
+	yellow = "#f1fa8c",
+	orange = "#ffb86c",
+	purple = "#BF40BF",
+	violet = "#7F00FF",
+	red = "#ff5555",
+	cyan = "#66d9eC",
+	diag = {
+		warn = utils.get_highlight("DiagnosticSignWarn").fg,
+		error = utils.get_highlight("DiagnosticSignError").fg,
+		hint = utils.get_highlight("DiagnosticSignHint").fg,
+		info = utils.get_highlight("DiagnosticSignInfo").fg,
+	},
+	git = {
+		del = "#e95678",
+		add = "#a6e22e",
+		change = "#ae81ff",
+	},
+}
+
+require("heirline").load_colors(colors)
+
+local Align = { provider = "%=", hl = { bg = colors.bg } }
+local Space = { provider = " ", hl = { bg = colors.bg } }
+local Tab = { provider = " " }
+local LeftSpace = { provider = "" }
+local RightSpace = { provider = "" }
+local RightSpace2 = { provider = "" }
+local RightSpace3 = { provider = "" }
+local Fill = { provider = "%=", hl = { bg = colors.nobg } }
+local LeftSep = { provider = "" }
+local RightSep = { provider = "" }
+
+local ViMode = {
+	init = function(self)
+		self.mode = vim.fn.mode(1)
+		if not self.once then
+			vim.cmd("au ModeChanged *:*o redrawstatus")
+		end
+		self.once = true
+	end,
+	static = {
+		mode_names = {
+			n = "NORMAL ",
+			no = "N·OPERATOR PENDING ",
+			nov = "N?",
+			noV = "N?",
+			["no\22"] = "N? ",
+			niI = "Ni",
+			niR = "Nr",
+			niV = "Nv",
+			nt = "Nt",
+			v = "VISUAL ",
+			vs = "Vs",
+			V = "V·LINE ",
+			["\22"] = "V·BLOCK ",
+			["\22s"] = "V·BLOCK ",
+			s = "SELECT ",
+			S = "S·LINE ",
+			["\19"] = "S·BLOCK ",
+			i = "INSERT ",
+			ix = "insert x ",
+			ic = "insert c ",
+			R = "REPLACE ",
+			Rc = "Rc",
+			Rx = "Rx",
+			Rv = "V·REPLACE ",
+			Rvc = "Rv",
+			Rvx = "Rv",
+			c = "COMMAND ",
+			cv = "VIM EX ",
+			ce = "EX ",
+			r = "PROMPT ",
+			rm = "MORE ",
+			["r?"] = "CONFIRM ",
+			["!"] = "SHELL ",
+			t = "TERMINAL ",
+		},
+	},
+	provider = function(self)
+		return "  %2(" .. self.mode_names[self.mode] .. "%) "
+	end,
+	hl = function(self)
+		local color = self:mode_color()
+		return { fg = color, bold = true }
+	end,
+	update = {
+		"ModeChanged",
+	},
+}
+
+-- LSP
+local LSPActive = {
+	condition = conditions.lsp_attached,
+	update = { "LspAttach", "LspDetach" },
+
+	provider = function()
+		local buf_clients = vim.lsp.buf_get_clients()
+		local buf_client_names = {}
+
+		-- add client
+		for _, client in pairs(buf_clients) do
+			if client.name ~= "null-ls" then
+				table.insert(buf_client_names, client.name)
+			end
+		end
+		return "⚙️ " .. table.concat(buf_client_names, "")
+	end,
+	hl = { fg = colors.lightgray, bold = false },
+}
+
+-- Navic
+local Navic = {
+	condition = require("nvim-navic").is_available,
+	static = {
+		-- create a type highlight map
+		type_hl = {
+			File = "Directory",
+			Module = "Include",
+			Namespace = "TSNamespace",
+			Package = "Include",
+			Class = "Struct",
+			Method = "Method",
+			Property = "TSProperty",
+			Field = "TSField",
+			Constructor = "TSConstructor ",
+			Enum = "TSField",
+			Interface = "Type",
+			Function = "Function",
+			Variable = "TSVariable",
+			Constant = "Constant",
+			String = "String",
+			Number = "Number",
+			Boolean = "Boolean",
+			Array = "TSField",
+			Object = "Type",
+			Key = "TSKeyword",
+			Null = "Comment",
+			EnumMember = "TSField",
+			Struct = "Struct",
+			Event = "Keyword",
+			Operator = "Operator",
+			TypeParameter = "Type",
+		},
+	},
+	init = function(self)
+		local data = require("nvim-navic").get_data() or {}
+		local children = {}
+		-- create a child for each level
+		for i, d in ipairs(data) do
+			local child = {
+				{
+					provider = d.icon,
+					hl = self.type_hl[d.type],
+				},
+				{
+					provider = d.name,
+					-- highlight icon only or location name as well
+					-- hl = self.type_hl[d.type],
+				},
+			}
+			-- add a separator only if needed
+			if #data > 1 and i < #data then
+				table.insert(child, {
+					provider = " > ",
+					hl = { fg = colors.white },
+				})
+			end
+			table.insert(children, child)
+		end
+		-- instantiate the new child, overwriting the previous one
+		self[1] = self:new(children, 1)
+	end,
+	hl = { fg = colors.white },
+}
+
+-- Diagnostics
+local Diagnostics = {
+
+	condition = conditions.has_diagnostics,
+
+	static = {
+		error_icon = vim.fn.sign_getdefined("DiagnosticSignError")[1].text,
+		warn_icon = vim.fn.sign_getdefined("DiagnosticSignWarn")[1].text,
+		info_icon = vim.fn.sign_getdefined("DiagnosticSignInfo")[1].text,
+		hint_icon = vim.fn.sign_getdefined("DiagnosticSignHint")[1].text,
+	},
+
+	init = function(self)
+		self.errors = #vim.diagnostic.get(0, { severity = vim.diagnostic.severity.ERROR })
+		self.warnings = #vim.diagnostic.get(0, { severity = vim.diagnostic.severity.WARN })
+		self.hints = #vim.diagnostic.get(0, { severity = vim.diagnostic.severity.HINT })
+		self.info = #vim.diagnostic.get(0, { severity = vim.diagnostic.severity.INFO })
+	end,
+
+	update = { "DiagnosticChanged", "BufEnter" },
+
+	{
+		provider = function(self)
+			-- 0 is just another output, we can decide to print it or not!
+			return self.errors > 0 and (self.error_icon .. self.errors .. " ")
+		end,
+		hl = { fg = colors.diag.error, bg = colors.bg },
+	},
+	{
+		provider = function(self)
+			return self.warnings > 0 and (self.warn_icon .. self.warnings .. " ")
+		end,
+		hl = { fg = colors.diag.warn, bg = colors.bg },
+	},
+	{
+		provider = function(self)
+			return self.info > 0 and (self.info_icon .. self.info .. " ")
+		end,
+		hl = { fg = colors.diag.info, bg = colors.bg },
+	},
+	{
+		provider = function(self)
+			return self.hints > 0 and (self.hint_icon .. self.hints)
+		end,
+		hl = { fg = colors.diag.hint, bg = colors.bg },
+	},
+	on_click = {
+		callback = function()
+			require("trouble").toggle({ mode = "document_diagnostics" })
+			-- or
+			-- vim.diagnostic.setqflist()
+		end,
+		name = "heirline_diagnostics",
+	},
+}
+
+-- Git
+-- For the ones who're not (too) afraid of changes! Uses gitsigns.
+local Git = {
+	condition = conditions.is_git_repo,
+
+	init = function(self)
+		self.status_dict = vim.b.gitsigns_status_dict
+		self.has_changes = self.status_dict.added ~= 0 or self.status_dict.removed ~= 0 or self.status_dict.changed ~= 0
+	end,
+	--hl = { fg = "orange" },
+	hl = { fg = colors.orange, bg = colors.bg },
+	{ -- git branch name
+		provider = function(self)
+			return " " .. self.status_dict.head
+		end,
+		--hl = { bold = true },
+		hl = { bold = true, bg = colors.bg },
+	},
+	-- You could handle delimiters, icons and counts similar to Diagnostics
+	{
+		condition = function(self)
+			return self.has_changes
+		end,
+		--provider = "("
+		provider = " ",
+	},
+	{
+		provider = function(self)
+			local count = self.status_dict.added or 0
+			--return count > 0 and ("+" .. count)
+			return count > 0 and ("  " .. count)
+		end,
+		--hl = { fg = "git_add" },
+		hl = { fg = colors.git.add, bg = colors.bg },
+	},
+	{
+		provider = function(self)
+			local count = self.status_dict.removed or 0
+			--return count > 0 and ("-" .. count)
+			return count > 0 and ("  " .. count)
+		end,
+		--hl = { fg = "git_del" },
+		hl = { fg = colors.git.del, bg = colors.bg },
+	},
+	{
+		provider = function(self)
+			local count = self.status_dict.changed or 0
+			--return count > 0 and ("~" .. count)
+			return count > 0 and (" 柳" .. count)
+		end,
+		--hl = { fg = "git_change" },
+		hl = { fg = colors.git.change, bg = colors.bg },
+	},
+	--{
+	--    condition = function(self)
+	--        return self.has_changes
+	--    end,
+	--    provider = ")",
+	--},
+	on_click = {
+		callback = function()
+			-- If you want to use Fugitive:
+			-- vim.cmd("G")
+
+			-- If you prefer Lazygit
+			-- use vim.defer_fn() if the callback requires
+			-- opening of a floating window
+			-- (this also applies to telescope)
+			vim.defer_fn(function()
+				vim.cmd("Lazygit")
+			end, 100)
+		end,
+		name = "heirline_git",
+	},
+}
+
+-- Debugger
+-- Display informations from nvim-dap!
+local DAPMessages = {
+	-- display the dap messages only on the debugged file
+	condition = function()
+		local session = require("dap").session()
+		if session then
+			local filename = vim.api.nvim_buf_get_name(0)
+			if session.config then
+				local progname = session.config.program
+				return filename == progname
+			end
+		end
+		return false
+	end,
+	provider = function()
+		return " " .. require("dap").status()
+	end,
+	hl = { fg = utils.get_highlight("Debug").fg },
+	-- Debugger on_click: step-over, step-into, next, previous, stop buttons
+	--    coming soon!
+}
+
+-- Tests
+-- This requires the great ultest.
+--local UltTest = {
+--    condition = function()
+--        return vim .api.nvim_call_function("ultest#is_test_file", {}) ~= 0
+--    end,
+--    static = {
+--        passed_icon = vim.fn.sign_getdefined("test_pass")[1].text,
+--        failed_icon = vim.fn.sign_getdefined("test_fail")[1].text,
+--        passed_hl = { fg = utils.get_highlight("UltestPass").fg },
+--        failed_hl = { fg = utils.get_highlight("UltestFail").fg },
+--    },
+--    init = function(self)
+--        self.status = vim.api.nvim_call_function("ultest#status", {})
+--    end,
+--
+--    -- again, if you'd like icons and numbers to be colored differently,
+--    -- just split the component in two
+--    {
+--        provider = function(self)
+--            return self.passed_icon .. self.status.passed .. " "
+--        end,
+--        hl = function(self)
+--            return self.passed_hl
+--        end,
+--    },
+--    {
+--        provider = function(self)
+--            return self.failed_icon .. self.status.failed .. " "
+--        end,
+--        hl = function(self)
+--            return self.failed_hl
+--        end,
+--    },
+--    {
+--        provider = function(self)
+--            return "of " .. self.status.tests - 1
+--        end,
+--    },
+--}
+
+-- FileNameBlock: FileIcon, FileName and friends
+local FileNameBlock = {
+	-- let's first set up some attributes needed by this component and it's children
+	init = function(self)
+		self.filename = vim.api.nvim_buf_get_name(0)
+	end,
+	--hl = { fg = utils.get_highlight("Statusline").fg, bold = true, bg = colors.bg },
+	hl = { bg = colors.bg },
+}
+
+-- FileIcon, FileName, FileFlags and FileNameModifier
+local FileIcon = {
+	init = function(self)
+		local filename = self.filename
+		local extension = vim.fn.fnamemodify(filename, ":e")
+		self.icon, self.icon_color =
+			require("nvim-web-devicons").get_icon_color(filename, extension, { default = true })
+	end,
+	provider = function(self)
+		return self.icon and (self.icon .. " ")
+	end,
+	hl = function(self)
+		return { fg = self.icon_color, bg = colors.bg }
+	end,
+}
+
+local FileName = {
+	provider = function(self)
+		-- first, trim the pattern relative to the current directory. For other
+		-- options, see :h filename-modifers
+		local filename = vim.fn.fnamemodify(self.filename, ":.")
+		if filename == "" then
+			return "No Name"
+		end
+		-- now, if the filename would occupy more than 1/4th of the available
+		-- space, we trim the file path to its initials
+		-- See Flexible Components section below for dynamic truncation
+		if not conditions.width_percent_below(#filename, 0.25) then
+			filename = vim.fn.pathshorten(filename)
+		end
+		return filename
+	end,
+	--hl = { fg = utils.get_highlight("Statusline").fg, bold = false, bg = colors.bg },
+	hl = { fg = colors.white, bold = false, bg = colors.bg },
+}
+
+local FileFlags = {
+	{
+		provider = function()
+			if vim.bo.modified then
+				return " [+]" -- ±[+]
+			end
+		end,
+		hl = { fg = colors.green, bg = colors.bg },
+	},
+	{
+		provider = function()
+			if not vim.bo.modifiable or vim.bo.readonly then
+				return " "
+			end
+		end,
+		--hl = { fg = colors.orange },
+		hl = { fg = colors.orange, bold = true, bg = colors.bg },
+	},
+}
+
+local FileNameModifier = {
+	hl = function()
+		if vim.bo.modified then
+			return { fg = colors.green, bold = false, force = true }
+		end
+	end,
+}
+
+-- FileType, FileEncoding and FileFormat
+local FileType = {
+	provider = function()
+		return vim.bo.filetype
+	end,
+	hl = { fg = colors.white, bold = false, bg = colors.bg },
+}
+
+local FileEncoding = {
+	Space,
+	provider = function()
+		local enc = (vim.bo.fenc ~= "" and vim.bo.fenc) or vim.o.enc -- :h 'enc'
+		return enc:lower()
+	end,
+	--hl = { fg = utils.get_highlight("Statusline").fg, bold = true, bg = colors.bg },
+	hl = { bg = colors.bg, bold = false },
+}
+
+local FileFormat = {
+	provider = function()
+		local fmt = vim.bo.fileformat
+		--return fmt ~= "unix" and fmt:upper()
+		return fmt ~= "unix" and fmt:lower()
+	end,
+	hl = { fg = utils.get_highlight("Statusline").fg, bold = true, bg = colors.bg },
+}
+
+-- FileSize and FileLastModified
+local FileSize = {
+	provider = function()
+		-- stackoverflow, compute human readable file size
+		local suffix = { "b", "k", "M", "G", "T", "P", "E" }
+		local fsize = vim.fn.getfsize(vim.api.nvim_buf_get_name(0))
+		fsize = (fsize < 0 and 0) or fsize
+		if fsize < 1024 then
+			return fsize .. suffix[1]
+		end
+		local i = math.floor((math.log(fsize) / math.log(1024)))
+		return string.format("%.2g%s", fsize / math.pow(1024, i), suffix[i + 1])
+	end,
+	hl = { fg = utils.get_highlight("Statusline").fg, bold = true, bg = colors.bg },
+}
+
+local FileLastModified = {
+	-- did you know? Vim is full of functions!
+	provider = function()
+		local ftime = vim.fn.getftime(vim.api.nvim_buf_get_name(0))
+		return (ftime > 0) and os.date("%c", ftime)
+	end,
+	hl = { fg = utils.get_highlight("Statusline").fg, bold = true, bg = colors.bg },
+}
+
+-- Spell
+-- Add indicator when spell is set!
+local Spell = {
+	condition = function()
+		return vim.wo.spell
+	end,
+	provider = " 暈",
+	hl = { bold = true, fg = colors.yellow },
+}
+
+local help_file_name = {
+	condition = function()
+		return vim.bo.filetype == "help"
+	end,
+	provider = function()
+		local filename = vim.api.nvim_buf_get_name(0)
+		return vim.fn.fnamemodify(filename, ":t")
+	end,
+	hl = { fg = colors.blue },
+}
+
+-- Cursor position: Ruler
+--local Ruler = {
+	-- %l = current line number
+	-- %L = number of lines in the buffer
+	-- %c = column number
+	-- %P = percentage through file of displayed window
+	--provider = "%P %(%l/%L%):%c ",
+	--provider = "%3(%2l%):%c %P ",
+	--provider = "%7(%l/%3L%):%2c%P ",
+	--provider = "%3(%P%)",
+	--provider = "%7(%l/%3L%):%2c %P",
+	--provider = "%7 %p%% Ln %l, Col %c",
+	--provider = "%9( %P %2l/%L :%2c %)",
+	--provider = "%9(%2l%2( : %c%)/%L %P %)",
+	--provider = "%7(%l:%c/%L%) ",
+	--provider = "%6(%l:%1.5c/%L%) %P ",
+	--provider = "%6(%l:%1.5c/%L%) ",
+	--provider = "%3(%l:%1.5c/%L%)  ",
+	--provider = "%7(%l/%3L%):%2c ",
+--	provider = "%7(%l:%c%) ",
+	--provider = "%l:%c ",
+	--hl = { fg = utils.get_highlight("Statusline").fg, bold = true },
+--	hl = { fg = colors.darkgray, bold = true },
+--}
+local leftruler = { Space, Align }
+local rightruler = { Align, Space }
+local cursor_location = {
+  --{ provider = "", hl = { fg = utils.get_highlight("StatusLine").bg, bold = true } },
+--	{ provider = "%<%-05.10(%l:%c%)", hl = { fg = colors.darkgray, bold = true } },
+--	{ provider = "  ", hl = { fg = colors.darkgray, bold = true } },
+  --{ provider = "%P %=%<%(%l,%c)" },
+  --{ provider = "   %w%-8.(%l,%c%)%>" },
+  { provider = " %1(%4l:%-3(%c%) %)%*", hl = { fg = colors.black, bold = true } },
+}
+local Ruler = { cursor_location }
+
+	--utils.make_flexible_component(
+	--	3,
+	--	{ Ruler, hl = { fg = utils.get_highlight("statusline").bg, force = true } },
+	--	{ provider = "%<" }
+	--),
+--local cursor_location = {
+--	{ provider = "%7(%l:%c%) ", hl = { bold = true } },
+--	{
+--		provider = " ",
+--		hl = function(self)
+--			local color = self:mode_color()
+--			return { fg = color, bold = true }
+--		end,
+--	},
+--}
+
+local WordCount = {
+	condition = function()
+		return conditions.buffer_matches({
+			filetype = {
+				"markdown",
+				"txt",
+				"vimwiki",
+			},
+		})
+	end,
+	Space,
+	{
+		provider = function()
+			return "W:" .. vim.fn.wordcount().words
+		end,
+	},
+}
+
+-- Working Directory
+local WorkDir = {
+	provider = function(self)
+		self.icon = (vim.fn.haslocaldir(0) == 1 and "l" or "g") .. " " .. " "
+		local cwd = vim.fn.getcwd(0)
+		self.cwd = vim.fn.fnamemodify(cwd, ":~")
+	end,
+	hl = { fg = colors.blue, bold = true, bg = colors.bg },
+
+	utils.make_flexible_component(1, {
+		-- evaluates to the full-lenth path
+		provider = function(self)
+			local trail = self.cwd:sub(-1) == "/" and "" or "/"
+			return self.icon .. self.cwd .. trail .. " "
+		end,
+	}, {
+		-- evaluates to the shortened path
+		provider = function(self)
+			local cwd = vim.fn.pathshorten(self.cwd)
+			local trail = self.cwd:sub(-1) == "/" and "" or "/"
+			return self.icon .. cwd .. trail .. " "
+		end,
+	}, {
+		-- evaluates to "", hiding the component
+		provider = "",
+	}),
+}
+
+-- Snippets Indicator
+-- This requires ultisnips
+--local Snippets = {
+--    -- check that we are in insert or select mode
+--    condition = function()
+--        return vim.tbl_contains({'s', 'i'}, vim.fn.mode())
+--    end,
+--    provider = function()
+--        local forward = (vim.fn["UltiSnips#CanJumpForwards"]() == 1) and "" or ""
+--        local backward = (vim.fn["UltiSnips#CanJumpBackwards"]() == 1) and " " or ""
+--        return backward .. forward
+--    end,
+--    hl = { fg = "red", bold = true },
+--}
+
+-- let's add the children to our FileNameBlock component
+FileNameBlock = utils.insert(
+	FileNameBlock,
+	FileIcon,
+	utils.insert(FileNameModifier, FileName), -- a new table where FileName is a child of FileNameModifier
+	unpack(FileFlags), -- A small optimisation, since their parent does nothing
+	{ provider = "%<" } -- this means that the statusline is cut here when there's not enough space
+)
+
+local FileInfoBlock = {
+	-- let's first set up some attributes needed by this component and it's children
+	init = function(self)
+		self.filename = vim.api.nvim_buf_get_name(0)
+	end,
+}
+
+FileInfoBlock = utils.insert(
+	FileInfoBlock,
+	Space,
+	FileIcon,
+	FileType,
+	{ provider = "%<" } -- this means that the statusline is cut here when there's not enough space
+)
+
+--ViMode = utils.surround({ "", "" }, function(self)
+--	return self:mode_color()
+--end, { ViMode, hl = { fg = utils.get_highlight("statusline").bg, force = true } })
+--local mysurroundedcomponent = {
+--{provider='', hl = {...}},
+--{<your component>},
+--{provider = '>>>', hl = {...}}
+--}
+LeftSpace = utils.surround({ "", " " }, function(self)
+	return self:mode_color()
+end, { LeftSpace, hl = { fg = utils.get_highlight("statusline").bg, force = true } })
+
+RightSpace = utils.surround(
+	{ "", "" },
+	colors.gray,
+	{ RightSpace, hl = { bg = utils.get_highlight("statusline").bg, force = true } }
+)
+
+RightSpace2 = utils.surround(
+	{ "█", "" },
+	colors.darkgray,
+	{ RightSpace2, hl = { fg = colors.darkgray, force = true } }
+)
+
+RightSpace3 = utils.surround(
+	{ "█", "" },
+	utils.get_highlight("statusline").bg,
+	{ RightSpace3, hl = { fg = colors.darkgray, force = true } }
+)
+
+LSPActive = utils.surround({ "", "" }, function(self)
+	return self:mode_color()
+end, { Space, LSPActive, hl = { bg = colors.darkgray, force = true } })
+
+FileInfoBlock = utils.surround({ "", "" }, function(self)
+	return self:mode_color()
+end, { FileInfoBlock, Space, hl = { bg = colors.gray, force = true } })
+
+Ruler = utils.surround({ "", "" }, colors.gray, { Ruler, hl = { fg = colors.gray, force = true } })
+
+local left = {
+	{ ViMode, hl = { fg = utils.get_highlight("statusline").bg, force = true } },
+	--{ LeftSep, hl = function(self)
+  --      return { fg = self.mode_colors[self.mode], bg = utils.get_highlight("statusline").bg, bold = true, }
+  --  end,
+  --},
+	{ LeftSpace, hl = { bg = utils.get_highlight("statusline").bg, force = true } },
+	{ FileNameBlock, hl = { bg = utils.get_highlight("statusline").bg, force = true } },
+	{ Space, hl = { bg = utils.get_highlight("statusline").bg, force = true } },
+	{ Git, hl = { bg = utils.get_highlight("statusline").bg, force = true } },
+}
+local middle = {
+	{ Align, hl = { bg = utils.get_highlight("statusline").bg, force = true } },
+	{ Navic, hl = { bg = utils.get_highlight("statusline").bg, force = true } },
+	{ DAPMessages, hl = { bg = utils.get_highlight("statusline").bg, force = true } },
+	{ Align, hl = { bg = utils.get_highlight("statusline").bg, force = true } },
+}
+local right = {
+	{ Diagnostics, hl = { bg = utils.get_highlight("statusline").bg, force = true } },
+	{
+		RightSpace3,
+		hl = { bg = colors.darkgray, force = true },
+	},
+	{ LSPActive, hl = { bg = colors.darkgray, force = true } },
+	{ RightSpace2, hl = { bg = colors.gray, force = true } },
+	{ FileInfoBlock, hl = { bg = colors.gray, force = true } },
+	{ RightSpace, hl = { fg = colors.gray, force = true } },
+	--{ cursor_location, hl = { fg = utils.get_highlight("statusline").bg, force = true } },
+	{ Ruler, hl = { fg = utils.get_highlight("statusline").bg, force = true } },
+	--utils.make_flexible_component(
+	--	3,
+	--	{ Ruler, hl = { fg = utils.get_highlight("statusline").bg, force = true } },
+	--	{ provider = "%<" }
+	--),
+}
+--local Align = { provider = "%=", hl = { bg = colors.bg } }
+
+local sections = { left, middle, right }
+local DefaultStatusline = { sections }
+--LSPActive, Space, LSPMessages, Space, UltTest, Space, FileType, Space, Ruler, Space, ScrollBar
+
+local InactiveStatusline = {
+	condition = conditions.is_not_active,
+	{ FileType, hl = { bg = utils.get_highlight("statusline").bg, force = true } },
+	{ Space, hl = { bg = utils.get_highlight("statusline").bg, force = true } },
+	{ FileName, hl = { bg = utils.get_highlight("statusline").bg, force = true } },
+	{ Align, hl = { bg = utils.get_highlight("statusline").bg, force = true } },
+}
+
+local SpecialStatusline = {
+	condition = function()
+		return conditions.buffer_matches({
+			buftype = { "nofile", "prompt", "help", "quickfix" },
+			filetype = { "^git.*", "fugitive" },
+		})
+	end,
+
+	--FileType,
+	--Space,
+	--Align,
+	{ ViMode, hl = { fg = utils.get_highlight("statusline").bg, force = true } },
+	{ LeftSpace, hl = { bg = utils.get_highlight("statusline").bg, force = true } },
+	{ FileType, hl = { bg = utils.get_highlight("statusline").bg, force = true } },
+	{ Space, hl = { bg = utils.get_highlight("statusline").bg, force = true } },
+	{ Align, hl = { bg = utils.get_highlight("statusline").bg, force = true } },
+	{ RightSpace, hl = { fg = utils.get_highlight("statusline").bg, force = true } },
+	{ Ruler, hl = { fg = utils.get_highlight("statusline").bg, force = true } },
+}
+
+local TerminalStatusline = {
+
+	condition = function()
+		return conditions.buffer_matches({ buftype = { "terminal" } })
+	end,
+
+	--hl = { bg = colors.red },
+
+	-- Quickly add a condition to the ViMode to only show it when buffer is active!
+	--{ condition = conditions.is_active, ViMode, Space },
+	{ ViMode, hl = { fg = utils.get_highlight("statusline").bg, force = true } },
+	{ LeftSpace, hl = { bg = utils.get_highlight("statusline").bg, force = true } },
+	{ FileType, hl = { bg = utils.get_highlight("statusline").bg, force = true } },
+	{ Space, hl = { bg = utils.get_highlight("statusline").bg, force = true } },
+	{ Align, hl = { bg = utils.get_highlight("statusline").bg, force = true } },
+	{ RightSpace, hl = { fg = utils.get_highlight("statusline").bg, force = true } },
+	{ Ruler, hl = { fg = utils.get_highlight("statusline").bg, force = true } },
+	--FileType,
+	--Space,
+	--TerminalName,
+	--Align,
+}
+
+local StatusLine = {
+
+	--hl = function()
+	--	if conditions.is_active() then
+	--		return "StatusLine"
+	--	else
+	--		return "StatusLineNC"
+	--	end
+	--end,
+	static = {
+		mode_colors = {
+			n = colors.blue,
+			i = colors.green,
+			v = colors.purple,
+			V = colors.purple,
+			["\22"] = colors.purple,
+			c = colors.orange,
+			s = colors.purple,
+			S = colors.purple,
+			["\19"] = colors.purple,
+			R = colors.red,
+			r = colors.red,
+			["!"] = colors.orange,
+			t = colors.orange,
+		},
+		mode_color = function(self)
+			local mode = conditions.is_active() and vim.fn.mode() or "n"
+			return self.mode_colors[mode]
+		end,
+		hl = function(self)
+			local color = self:mode_color() -- here!
+			return { bg = color }
+		end,
+	},
+	fallthrough = false,
+
+	SpecialStatusline,
+	TerminalStatusline,
+	InactiveStatusline,
+	DefaultStatusline,
+}
+
+
+--
+--- WinBar
+--
+local WinbarFileNameBlock = {
+	-- let's first set up some attributes needed by this component and it's children
+	init = function(self)
+		self.filename = vim.api.nvim_buf_get_name(0)
+	end,
+	hl = { bg = colors.bg },
+}
+
+--local WinbarFileName = {
+--	provider = function(self)
+--		-- self.filename will be defined later, just keep looking at the example!
+--		local filename = self.filename
+--		filename = filename == "" and "No Name" or vim.fn.fnamemodify(filename, ":t")
+--		return filename
+--	end,
+--	hl = function()
+--		return { fg = colors.gray, italic = true }
+--	end,
+--}
+local WinbarFileName = {
+	provider = function(self)
+		-- first, trim the pattern relative to the current directory. For other
+		-- options, see :h filename-modifers
+		local filename = vim.fn.fnamemodify(self.filename, ":.")
+		if filename == "" then
+			return "No Name"
+		end
+		-- now, if the filename would occupy more than 1/4th of the available
+		-- space, we trim the file path to its initials
+		-- See Flexible Components section below for dynamic truncation
+		if not conditions.width_percent_below(#filename, 0.25) then
+			filename = vim.fn.pathshorten(filename)
+		end
+		return filename
+	end,
+	--hl = { fg = utils.get_highlight("Statusline").fg, bold = false, bg = colors.bg },
+	hl = { fg = colors.gray, bold = false, bg = colors.bg },
+}
+
+WinbarFileNameBlock = utils.insert(
+	WinbarFileNameBlock,
+	FileIcon,
+	utils.insert(WinbarFileName), -- a new table where FileName is a child of FileNameModifier
+	unpack(FileFlags), -- A small optimisation, since their parent does nothing
+	{ provider = "%<" } -- this means that the statusline is cut here when there's not enough space
+)
+
+vim.api.nvim_create_autocmd("User", {
+	pattern = "HeirlineInitWinbar",
+	callback = function(args)
+		local buf = args.buf
+		local buftype = vim.tbl_contains({ "prompt", "nofile", "help", "quickfix" }, vim.bo[buf].buftype)
+		local filetype = vim.tbl_contains({ "gitcommit", "fugitive" }, vim.bo[buf].filetype)
+		if buftype or filetype then
+			vim.opt_local.winbar = nil
+		end
+	end,
+})
+
+On_click = {
+	-- get the window id of the window in which the component was evaluated
+	minwid = function()
+		return vim.api.nvim_get_current_win()
+	end,
+	callback = function(_, minwid)
+		-- winid is the window id of the window the component was clicked from
+		local winid = minwid
+		-- do something with the window id, e.g.:
+		local buf = vim.api.nvim_win_get_buf(winid)
+		-- ...
+	end,
+}
+
+local CloseButton = {
+	condition = function(self)
+		return not vim.bo.modified
+	end,
+	-- a small performance improvement:
+	-- re register the component callback only on layout/buffer changes.
+	update = { "WinNew", "WinClosed", "BufEnter" },
+	{ provider = " " },
+	{
+		provider = "",
+		hl = { fg = "gray" },
+		On_click = {
+			minwid = function()
+				return vim.api.nvim_get_current_win()
+			end,
+			callback = function(_, minwid)
+				vim.api.nvim_win_close(minwid, true)
+			end,
+			name = "heirline_winbar_close_button",
+		},
+	},
+}
+
+local Center = {
+	fallthrough = false,
+	{ -- Hide the winbar for special buffers
+		condition = function()
+			return conditions.buffer_matches({
+				buftype = { "nofile", "prompt", "help", "quickfix" },
+				filetype = { "^git.*", "fugitive" },
+			})
+		end,
+		init = function()
+			vim.opt_local.winbar = nil
+		end,
+	},
+	{ -- A special winbar for terminals
+		condition = function()
+			return conditions.buffer_matches({ buftype = { "terminal" } })
+		end,
+		FileType,
+		Space,
+		--TerminalName,
+	},
+	{ -- An inactive winbar for regular files
+		condition = function()
+			return not conditions.is_active()
+		end,
+		--utils.surround({ "", "" }, colors.nobg, { FileIcon, { WinbarFileName, hl = { fg = colors.gray } }, FileFlags } ),
+		utils.surround({ "", "" }, colors.nobg, { WinbarFileNameBlock } ),
+	},
+	-- A winbar for regular files
+	utils.surround({ "", "" }, colors.nobg, { FileNameBlock }),
+}
+
+--local WinBar = { Align, Center, Align }
+local WinBar = { Space, Center }
+
+
+-- TabLine
+local TablineBufnr = {
+	provider = function(self)
+		return tostring(self.bufnr) .. "."
+	end,
+	hl = { fg = colors.white, bold = false },
+}
+
+-- we redefine the filename component, as we probably only want the tail and not the relative path
+local TablineFileName = {
+	provider = function(self)
+		-- self.filename will be defined later, just keep looking at the example!
+		local filename = self.filename
+		filename = filename == "" and "No Name" or vim.fn.fnamemodify(filename, ":t")
+		return filename
+	end,
+	hl = function(self)
+		return { fg = colors.white, bold = self.is_active or self.is_visible, italic = true }
+	end,
+}
+
+local TablineFileFlags = {
+	{
+		provider = function(self)
+			if vim.bo[self.bufnr].modified then
+				return " [+] "
+			end
+		end,
+		hl = { fg = colors.green },
+	},
+	{
+		provider = function(self)
+			if not vim.bo[self.bufnr].modifiable or vim.bo[self.bufnr].readonly then
+				return "  "
+			end
+		end,
+		hl = { fg = "orange" },
+	},
+}
+
+local TablineFileIcon = {
+	init = function(self)
+		local filename = self.filename
+		local extension = vim.fn.fnamemodify(filename, ":e")
+		self.icon, self.icon_color =
+			require("nvim-web-devicons").get_icon_color(filename, extension, { default = true })
+	end,
+	provider = function(self)
+		return self.icon and (" " .. self.icon .. " ")
+	end,
+	hl = function(self)
+		return { fg = self.icon_color }
+	end,
+}
+
+-- Here the filename block finally comes together
+local TablineFileNameBlock = {
+	init = function(self)
+		self.filename = vim.api.nvim_buf_get_name(self.bufnr)
+	end,
+	hl = function(self)
+		if self.is_active then
+			return "TabLineSel"
+		-- why not?
+		--elseif not vim.api.nvim_buf_is_loaded(self.bufnr) then
+		--return { fg = "gray", bg = colors.bg }
+		else
+			return "TabLineFill"
+		end
+	end,
+	on_click = {
+		callback = function(_, minwid, _, button)
+			if button == "m" then -- close on mouse middle click
+				vim.api.nvim_buf_delete(minwid, { force = false })
+			else
+				vim.api.nvim_win_set_buf(0, minwid)
+			end
+		end,
+		minwid = function(self)
+			return self.bufnr
+		end,
+		name = "heirline_tabline_buffer_callback",
+	},
+	TablineBufnr,
+	TablineFileIcon,
+	TablineFileName,
+	TablineFileFlags,
+}
+
+-- a nice "x" button to close the buffer
+local TablineCloseButton = {
+	condition = function(self)
+		return not vim.api.nvim_buf_get_option(self.bufnr, "modified")
+	end,
+	{ provider = " " },
+	{
+		provider = " ",
+		--hl = { fg = "red", bg = colors.bg },
+		hl = { fg = colors.red },
+		on_click = {
+			callback = function(_, minwid)
+				vim.api.nvim_buf_delete(minwid, { force = false })
+			end,
+			minwid = function(self)
+				return self.bufnr
+			end,
+			name = "heirline_tabline_close_buffer_callback",
+		},
+	},
+}
+
+-- The final touch!
+local TablineBufferBlock = utils.surround({ "", "" }, function(self)
+	--local TablineBufferBlock = utils.surround({ "█", "█" }, function(self)
+	if self.is_active then
+		return utils.get_highlight("TabLineSel").bg
+	else
+		return utils.get_highlight("TabLineFill").bg
+	end
+end, { Tab, TablineFileNameBlock, TablineCloseButton })
+
+local BufferLine = utils.make_buflist(
+	TablineBufferBlock,
+	{ provider = "􀰎 ", hl = { fg = colors.white } }, -- left truncation, optional (defaults to "<")
+	{ provider = " 􀰓", hl = { fg = colors.white } } -- right trunctation, also optional (defaults to ...... yep, ">")
+	-- by the way, open a lot of buffers and try clicking them ;)
+)
+-- TabList
+local Tabpage = {
+	provider = function(self)
+		return "%" .. self.tabnr .. "T " .. self.tabnr .. " %T"
+	end,
+	hl = function(self)
+		if not self.is_active then
+			return "TabLineFill"
+		else
+			return "TabLineSel"
+		end
+	end,
+}
+
+local TabpageClose = {
+	provider = "%999X  %X",
+	--hl = "TabLine",
+	hl = { fg = colors.red, bg = colors.bg },
+}
+
+local TabPages = {
+	-- only show this component if there's 2 or more tabpages
+	condition = function()
+		return #vim.api.nvim_list_tabpages() >= 2
+	end,
+	{
+		provider = "%=",
+	},
+	utils.make_tablist(Tabpage),
+	TabpageClose,
+}
+
+-- TabLineOffset
+local TabLineOffset = {
+	condition = function(self)
+		local win = vim.api.nvim_tabpage_list_wins(0)[1]
+		local bufnr = vim.api.nvim_win_get_buf(win)
+		self.winid = win
+
+		if vim.api.nvim_buf_get_option(bufnr, "filetype") == "NvimTree" then
+			self.title = "NvimTree"
+			return true
+		end
+	end,
+
+	provider = function(self)
+		local title = self.title
+		local width = vim.api.nvim_win_get_width(self.winid)
+		local pad = math.ceil((width - #title) / 2)
+		return string.rep(" ", pad) .. title .. string.rep(" ", pad)
+	end,
+
+	hl = function(self)
+		if vim.api.nvim_get_current_win() == self.winid then
+			return "TablineSel"
+		else
+			return "TablineFill"
+		end
+	end,
+}
+
+local TabLine = {
+	TabLineOffset,
+	BufferLine,
+	TabPages,
+}
+
+require("heirline").setup(StatusLine, WinBar, TabLine)
+
+-- Yep, with heirline we're driving manual!
+--vim.cmd([[au FileType * if index(['wipe', 'delete', 'unload'], &bufhidden) >= 0 | set nobuflisted | endif]])
+--
+--local function get_bufs()
+--	return vim.tbl_filter(function(bufnr)
+--		return vim.api.nvim_buf_is_loaded(bufnr) and vim.bo[bufnr].buflisted
+--	end, vim.api.nvim_list_bufs())
+--end
+--
+--local function goto_buf(index)
+--	local bufs = get_bufs()
+--	if index > #bufs then
+--		index = #bufs
+--	end
+--	vim.api.nvim_win_set_buf(0, bufs[index])
+--end
+--
+--local function addKey(key, index)
+--	vim.keymap.set("", "<A-" .. key .. ">", function()
+--		goto_buf(index)
+--	end, { noremap = true, silent = true })
+--end
+--
+--for i = 1, 9 do
+--	addKey(i, i)
+--end
+--addKey("0", 10)
diff --git a/lua/plugins/linecolor.lua b/lua/plugins/linecolor.lua
new file mode 100644
index 0000000..37550dd
--- /dev/null
+++ b/lua/plugins/linecolor.lua
@@ -0,0 +1,112 @@
+--local M = {}
+--M.theme = function()
+--  -- I know I could just set bg = nil but I'm leaving this here in case I want custom colors in the future
+--  local colors = {
+--    nobg = nil,
+--    blue = "#87b0f9",
+--    mauve = "#cba6f7",
+--    red = "#f38ba8",
+--    green = "#a6e3a1",
+--    peach = "#fab387",
+--    white = "#c6d0f5",
+--    gray = "#a1a8c9",
+--    black = "#1e1e2e",
+--  }
+--  return {
+--    inactive = {
+--      a = { fg = colors.blue, bg = colors.nobg, gui = "bold" },
+--      b = { fg = colors.white, bg = colors.black },
+--      c = { fg = colors.gray, bg = colors.nobg },
+--    },
+--    visual = {
+--      a = { fg = colors.black, bg = colors.mauve, gui = "bold" },
+--      b = { fg = colors.mauve, bg = colors.nobg },
+--      c = { fg = colors.white, bg = colors.nobg },
+--    },
+--    replace = {
+--      a = { fg = colors.black, bg = colors.red, gui = "bold" },
+--      b = { fg = colors.red, bg = colors.nobg },
+--      c = { fg = colors.white, bg = colors.nobg },
+--    },
+--    normal = {
+--      a = { fg = colors.black, bg = colors.blue, gui = "bold" },
+--      b = { fg = colors.black, bg = colors.green },
+--      c = { fg = colors.white, bg = colors.black },
+--    },
+--    insert = {
+--      a = { fg = colors.black, bg = colors.green, gui = "bold" },
+--      b = { fg = colors.teal, bg = colors.nobg },
+--      c = { fg = colors.white, bg = colors.nobg },
+--    },
+--    command = {
+--      a = { fg = colors.black, bg = colors.peach, gui = "bold" },
+--      b = { fg = colors.peach, bg = colors.nobg },
+--      c = { fg = colors.white, bg = colors.nobg },
+--    },
+--    modified = {
+--      a = { fg = colors.black, bg = colors.peach, gui = "bold" },
+--      b = { fg = colors.peach, bg = colors.peach },
+--      c = { fg = colors.white, bg = colors.peach },
+--    },
+--  }
+--end
+--return M
+local M = {}
+M.theme = function()
+	--local colors = {
+	--	darkgray = "#16161d",
+	--	gray = "#727169",
+	--	innerbg = nil,
+	--	outerbg = "#16161D",
+	--	normal = "#7e9cd8",
+	--	insert = "#98bb6c",
+	--	visual = "#ffa066",
+	--	replace = "#e46876",
+	--	command = "#e6c384",
+	--}
+	local colors = {
+		darkgray = "#16161d",
+		gray = "#727169",
+		innerbg = nil,
+		outerbg = "#16161D",
+		normal = "#39BAE6",
+		insert = "#AAD94C",
+		visual = "#FA8D3F",
+		replace = "#F07171",
+		command = "#F2AE49",
+	}
+	return {
+		inactive = {
+			a = { fg = colors.gray, bg = colors.outerbg, gui = "bold" },
+			b = { fg = colors.gray, bg = colors.outerbg },
+			c = { fg = colors.gray, bg = colors.innerbg },
+		},
+		visual = {
+			a = { fg = colors.darkgray, bg = colors.visual, gui = "bold" },
+			b = { fg = colors.gray, bg = colors.outerbg },
+			c = { fg = colors.gray, bg = colors.innerbg },
+		},
+		replace = {
+			a = { fg = colors.darkgray, bg = colors.replace, gui = "bold" },
+			b = { fg = colors.gray, bg = colors.outerbg },
+			c = { fg = colors.gray, bg = colors.innerbg },
+		},
+		normal = {
+			a = { fg = colors.darkgray, bg = colors.normal, gui = "bold" },
+			b = { fg = colors.gray, bg = colors.outerbg },
+			c = { fg = colors.gray, bg = colors.innerbg },
+			y = { fg = colors.gray, bg = colors.outerbg },
+		},
+		insert = {
+			a = { fg = colors.darkgray, bg = colors.insert, gui = "bold" },
+			b = { fg = colors.gray, bg = colors.outerbg },
+			c = { fg = colors.gray, bg = colors.innerbg },
+		},
+		command = {
+			a = { fg = colors.darkgray, bg = colors.command, gui = "bold" },
+			b = { fg = colors.gray, bg = colors.outerbg },
+			c = { fg = colors.gray, bg = colors.innerbg },
+		},
+	}
+end
+return M
diff --git a/lua/plugins/lsp-colors.lua b/lua/plugins/lsp-colors.lua
new file mode 100644
index 0000000..1398123
--- /dev/null
+++ b/lua/plugins/lsp-colors.lua
@@ -0,0 +1,9 @@
+local status, colors = pcall(require, "lsp-colors")
+if (not status) then return end
+
+colors.setup {
+  Error = "#db4b4b",
+  Warning = "#e0af68",
+  Information = "#0db9d7",
+  Hint = "#10B981"
+}
diff --git a/lua/plugins/lsp.lua b/lua/plugins/lsp.lua
new file mode 100644
index 0000000..f39cc58
--- /dev/null
+++ b/lua/plugins/lsp.lua
@@ -0,0 +1,598 @@
+
+local fn = vim.fn
+local keymap = vim.keymap
+
+local utils = require("user.utils")
+
+local custom_attach = function(client, bufnr)
+  -- Enable completion triggered by <c-x><c-o>
+  vim.api.nvim_buf_set_option(bufnr, 'omnifunc', 'v:lua.vim.lsp.omnifunc')
+
+	-- Mappings.
+	local map = function(mode, l, r, opts)
+		opts = opts or {}
+		opts.silent = true
+    opts.noremap = true
+		opts.buffer = bufnr
+		keymap.set(mode, l, r, opts)
+	end
+--map("n", "gd", "<Cmd>Lspsaga lsp_finder<CR>") -- Press "o" to open the reference location
+--map("n", "gp", "<Cmd>Lspsaga peek_definition<CR>")
+--	--map("n", "gd", vim.lsp.buf.definition, { desc = "go to definition" })
+  map("n", "<C-]>", vim.lsp.buf.definition)
+--	map("n", "K", vim.lsp.buf.hover)
+--	map("n", "<C-k>", vim.lsp.buf.signature_help)
+--	map("n", "<leader>rn", vim.lsp.buf.rename, { desc = "varialble rename" })
+--	map("n", "gr", vim.lsp.buf.references, { desc = "show references" })
+--	map("n", "[d", vim.diagnostic.goto_prev, { desc = "previous diagnostic" })
+--	map("n", "]d", vim.diagnostic.goto_next, { desc = "next diagnostic" })
+	map("n", "<leader>q", function()
+		vim.diagnostic.setqflist({ open = true })
+	end, { desc = "put diagnostic to qf" })
+--	--map.('n', '<space>q', vim.diagnostic.setloclist)
+--	map("n", "ga", vim.lsp.buf.code_action, { desc = "LSP code action" })
+--	map("n", "<leader>wa", vim.lsp.buf.add_workspace_folder, { desc = "add workspace folder" })
+--	map("n", "<leader>wr", vim.lsp.buf.remove_workspace_folder, { desc = "remove workspace folder" })
+--	map("n", "<leader>wl", function()
+--		print(vim.inspect(vim.lsp.buf.list_workspace_folders()))
+--	end, { desc = "list workspace folder" })
+--	map("n", "gs", "vim.lsp.buf.document_symbol()<cr>")
+--	map("n", "gw", "vim.lsp.buf.workspace_symbol()<cr>", { desc = "list workspace folder" })
+--	--map("n", "gs", ":lua vim.lsp.buf.document_symbol()<cr>")
+--	map("n", "gt", ":lua vim.lsp.buf.type_definition()<cr>")
+--	map("n", "gD", ":lua vim.lsp.buf.declaration()<cr>") -- most lsp servers don't implement textDocument/Declaration, so gD is useless for now.
+--	map("n", "gi", ":lua vim.lsp.buf.implementation()<cr>")
+	map("n", "go", ":lua vim.diagnostic.open_float()<cr>")
+--	map("n", "gk", "<Cmd>Lspsaga diagnostic_jump_prev<CR>")
+--	map("n", "gj", "<Cmd>Lspsaga diagnostic_jump_next<CR>")
+--vim.api.nvim_set_keymap('n', '<leader>dd', '<cmd>lua vim.diagnostic.setloclist()<CR>', { noremap = true, silent = true })
+  --nnoremap("gI", vim.lsp.buf.incoming_calls, opts)
+  --
+  --nnoremap("<leader>cs", vim.lsp.buf.document_symbol, opts)
+  --nnoremap("<leader>cw", vim.lsp.buf.workspace_symbol, opts)
+  --nnoremap("<leader>rf", vim.lsp.buf.formatting, opts)
+  --require("which-key").register {
+  --  ["<leader>rf"] = "lsp: format buffer",
+  --  ["<leader>ca"] = "lsp: code action",
+  --  ["<leader>gd"] = "lsp: go to type definition",
+  --  ["gr"] = "lsp: references",
+  --  ["gi"] = "lsp: implementation",
+  --  ["gI"] = "lsp: incoming calls",
+  --}
+--end
+vim.g.diagnostics_visible = true
+function _G.toggle_diagnostics()
+  if vim.g.diagnostics_visible then
+    vim.g.diagnostics_visible = false
+    vim.diagnostic.disable()
+  else
+    vim.g.diagnostics_visible = true
+    vim.diagnostic.enable()
+  end
+end
+map('n', '<Leader>m', ':call v:lua.toggle_diagnostics()<CR>')
+--vim.g.diagnostics_active = true
+--function _G.toggle_diagnostics()
+--  if vim.g.diagnostics_active then
+--    vim.g.diagnostics_active = false
+--    vim.lsp.diagnostic.clear(0)
+--      vim.cmd([[exe "normal ii\<Esc>x"]])
+--    vim.lsp.handlers["textDocument/publishDiagnostics"] = function() end
+--  else
+--    vim.g.diagnostics_active = true
+--    vim.lsp.handlers["textDocument/publishDiagnostics"] = vim.lsp.with(
+--      vim.lsp.diagnostic.on_publish_diagnostics, {
+--        virtual_text = true,
+--        signs = true,
+--        underline = true,
+--        update_in_insert = false,
+--      }
+--    )
+--  end
+--end
+--
+--map("n", "<leader>i", ":call v:lua.toggle_diagnostics()<CR>")
+
+
+	-- Set some key bindings conditional on server capabilities
+	if client.server_capabilities.documentFormattingProvider then
+		map("n", "<space>f", vim.lsp.buf.format, { desc = "format code" })
+	end
+
+	-- add rust specific keymappings
+	if client.name == "rust_analyzer" then
+		map("n", "<leader>rr", "<cmd>RustRunnables<CR>")
+		map("n", "<leader>ra", "<cmd>RustHoverAction<CR>")
+	end
+
+--For diagnostics for specific cursor position
+--vim.api.nvim_create_autocmd("CursorHold", {
+--  buffer = bufnr,
+--  callback = function()
+--    local opts = {
+--      focusable = false,
+--      close_events = { "BufLeave", "CursorMoved", "InsertEnter", "FocusLost" },
+--      border = 'rounded',
+--      source = 'always',
+--      prefix = ' ',
+--      scope = 'cursor',
+--    }
+--    vim.diagnostic.open_float(nil, opts)
+--  end
+--})
+	-- Diagnostic position
+--	vim.api.nvim_create_autocmd("CursorHold", {
+--		buffer = bufnr,
+--		callback = function()
+--			local float_opts = {
+--				focusable = false,
+--				close_events = { "BufLeave", "CursorMoved", "InsertEnter", "FocusLost" },
+--				border = "rounded",
+--				source = "always", -- show source in diagnostic popup window
+--				prefix = " ",
+--			}
+--
+--			if not vim.b.diagnostics_pos then
+--				vim.b.diagnostics_pos = { nil, nil }
+--			end
+--
+--			local cursor_pos = vim.api.nvim_win_get_cursor(0)
+--			if
+--				(cursor_pos[1] ~= vim.b.diagnostics_pos[1] or cursor_pos[2] ~= vim.b.diagnostics_pos[2])
+--				and #vim.diagnostic.get() > 0
+--			then
+--				vim.diagnostic.open_float(nil, float_opts)
+--			end
+--
+--			vim.b.diagnostics_pos = cursor_pos
+--		end,
+--	})
+
+	-- The below command will highlight the current variable and its usages in the buffer.
+	if client.server_capabilities.documentHighlightProvider then
+		vim.cmd([[
+      hi! link LspReferenceRead Visual
+      hi! link LspReferenceText Visual
+      hi! link LspReferenceWrite Visual
+      augroup lsp_document_highlight
+        autocmd! * <buffer>
+        autocmd CursorHold <buffer> lua vim.lsp.buf.document_highlight()
+        autocmd CursorMoved <buffer> lua vim.lsp.buf.clear_references()
+      augroup END
+    ]])
+	end
+
+	if vim.g.logging_level == "debug" then
+		local msg = string.format("Language server %s started!", client.name)
+		vim.notify(msg, vim.log.levels.DEBUG, { title = "Server?" })
+	end
+end
+
+local capabilities = vim.lsp.protocol.make_client_capabilities()
+capabilities = require("cmp_nvim_lsp").default_capabilities(capabilities)
+capabilities.textDocument.completion.completionItem.snippetSupport = true
+capabilities.offsetEncoding = { "utf-16" }
+
+local lspconfig = require("lspconfig")
+
+if utils.executable("pylsp") then
+	lspconfig.pylsp.setup({
+		settings = {
+			pylsp = {
+				plugins = {
+					pylint = { enabled = true, executable = "pylint" },
+					pyflakes = { enabled = false },
+					pycodestyle = { enabled = false },
+					jedi_completion = { fuzzy = true },
+					pyls_isort = { enabled = true },
+					pylsp_mypy = { enabled = true },
+				},
+			},
+		},
+		flags = {
+			debounce_text_changes = 200,
+		},
+		capabilities = capabilities,
+	})
+else
+	vim.notify("pylsp not found!", vim.log.levels.WARN, { title = "Server?" })
+end
+
+-- if utils.executable('pyright') then
+--   lspconfig.pyright.setup{
+--     on_attach = custom_attach,
+--     capabilities = capabilities
+--   }
+-- else
+--   vim.notify("pyright not found!", vim.log.levels.WARN, {title = 'Server?'})
+-- end
+
+if utils.executable("clangd") then
+	lspconfig.clangd.setup({
+		on_attach = custom_attach,
+		capabilities = capabilities,
+		filetypes = { "c", "cpp", "cc" },
+		flags = {
+			debounce_text_changes = 500,
+		},
+	})
+else
+	vim.notify("clangd not found!", vim.log.levels.WARN, { title = "Server?" })
+end
+
+-- set up vim-language-server
+if utils.executable("vim-language-server") then
+	lspconfig.vimls.setup({
+		on_attach = custom_attach,
+		flags = {
+			debounce_text_changes = 500,
+		},
+		capabilities = capabilities,
+	})
+else
+	vim.notify("vim-language-server not found!", vim.log.levels.WARN, { title = "Server?" })
+end
+
+-- set up bash-language-server
+if utils.executable("bash-language-server") then
+	lspconfig.bashls.setup({
+		on_attach = custom_attach,
+		capabilities = capabilities,
+	})
+end
+
+if utils.executable("lua-language-server") then
+	lspconfig.sumneko_lua.setup({
+		on_attach = custom_attach,
+		settings = {
+			Lua = {
+				runtime = {
+					-- Tell the language server which version of Lua you're using (most likely LuaJIT in the case of Neovim)
+					version = "LuaJIT",
+				},
+				diagnostics = {
+					-- Get the language server to recognize the `vim` global
+					globals = { "vim" },
+				},
+				workspace = {
+					-- Make the server aware of Neovim runtime files,
+					library = {
+						fn.stdpath("data") .. "/site/pack/packer/opt/emmylua-nvim",
+						fn.stdpath("config"),
+					},
+					maxPreload = 2000,
+					preloadFileSize = 50000,
+				},
+			},
+		},
+		capabilities = capabilities,
+	})
+end
+
+
+if utils.executable("rust-language-server") then
+require("lspconfig").rust_analyzer.setup{
+    cmd = { "rustup", "run", "nightly", "rust-analyzer" },
+    on_attach = custom_attach,
+  	flags = {
+			debounce_text_changes = 500,
+		},
+	--[[
+    settings = {
+        rust = {
+            unstable_features = true,
+            build_on_save = false,
+            all_features = true,
+        },
+    }
+    --]]
+}
+end
+
+--vim.diagnostic.config({
+--  virtual_text = false,
+--	underline = true,
+--})
+vim.diagnostic.config({
+    underline = false,
+    signs = true,
+    virtual_text = false,
+    float = {
+        show_header = true,
+        source = 'if_many',
+        border = 'rounded',
+        focusable = false,
+    },
+    update_in_insert = false, -- default to false
+    severity_sort = false, -- default to false
+})
+-- Show line diagnostics automatically in hover window
+--vim.o.updatetime = 250
+--vim.cmd [[autocmd CursorHold,CursorHoldI * lua vim.diagnostic.open_float(nil, {focusable = false,})]]
+--vim.cmd ([[ noremap <leader>a :autocmd! CursorHold,CursorHoldI <CR>]])
+
+--vim.cmd [[ noremap <leader>a :autocmd! CursorHold,CursorHoldI * lua vim.diagnostic.open_float(nil, {focusable = false,})<CR>]]
+--local diagnostics_active = true
+--local toggle_diagnostics = function()
+--  diagnostics_active = not diagnostics_active
+--  if diagnostics_active then
+--    vim.o.updatetime = 250
+--    vim.cmd ([[autocmd! CursorHold,CursorHoldI <CR>]])
+--    --vim.diagnostic.open_float(nil, {focus=false})
+--  else
+--    vim.o.updatetime = 250
+--    vim.cmd [[autocmd CursorHold,CursorHoldI * lua vim.diagnostic.open_float(nil, {focus=false})]]
+--    --vim.diagnostic.hide()
+--    --vim.diagnostic.disable()
+--  end
+--end
+--vim.keymap.set("n", "<leader>a", toggle_diagnostics)
+
+--function LspDiagnosticsFocus()
+--    vim.api.nvim_command('set eventignore=WinLeave')
+--    vim.api.nvim_command('autocmd CursorMoved <buffer> ++once set eventignore=""')
+--    vim.diagnostic.open_float(nil, {focusable = false, scope = 'line', close_events = {"CursorMoved", "CursorMovedI", "BufHidden", "InsertCharPre", "WinLeave"}})
+--end
+--vim.api.nvim_set_keymap('', '<Leader>a', '<Cmd>lua LspDiagnosticsFocus()<CR>', {silent = true})
+    --vim.o.updatetime = 250
+
+--    vim.o.updatetime = 250
+----vim.o.updatetime = 250
+----vim.cmd [[autocmd CursorHold,CursorHoldI * lua vim.diagnostic.open_float(nil, {focusable = false,})]]
+----local diagnostics_active = true
+--local toggle_diagnostics = function()
+--  --diagnostics_active = not diagnostics_active
+--  --if diagnostics_active then
+--  --if vim.diagnostic.open_float() == true then
+--  if vim.api.nvim_exec([[autocmd CursorHold,CursorHoldI * lua vim.diagnostic.open_float(nil, {focus=false})]]
+--, true) then
+--  vim.api.nvim_exec([[autocmd! CursorHold,CursorHoldI ]]
+--, true)
+--  else
+--    vim.o.updatetime = 250
+--  vim.api.nvim_exec([[autocmd CursorHold,CursorHoldI * lua vim.diagnostic.open_float(nil, {focus=false})]], true)
+--  end
+--end
+--vim.keymap.set("n", "<leader>a", toggle_diagnostics)
+--
+--vim.api.nvim_create_autocmd('CursorHold', {
+--      vim.diagnostic.open_float(nil, {focus=false})
+--
+--})
+
+vim.o.updatetime = 250
+vim.cmd[[ 
+augroup OpenFloat
+        autocmd CursorHold,CursorHoldI * lua vim.diagnostic.open_float(nil, {focusable = false,})
+
+augroup END
+]]
+vim.cmd([[
+function! ToggleDiagnosticsOpenFloat()
+    " Switch the toggle variable
+    let g:DiagnosticsOpenFloat = !get(g:, 'DiagnosticsOpenFloat', 1)
+
+    " Reset group
+    augroup OpenFloat
+            autocmd!
+    augroup END
+
+    " Enable if toggled on
+    if g:DiagnosticsOpenFloat
+        augroup OpenFloat
+            autocmd! CursorHold,CursorHoldI * lua vim.diagnostic.open_float(nil, {focusable = false,}) print ("vim.diagnostic.open_float enabled . . .")
+        augroup END
+    endif
+endfunction
+nnoremap <leader>a :call ToggleDiagnosticsOpenFloat()<CR>\|:echom "vim.diagnostic.open_float disabled . . ."<CR>
+]])
+
+--vim.lsp.handlers["textDocument/hover"] = vim.lsp.with(
+--  vim.lsp.handlers.hover, {
+--    signs = true,
+--    underline = false,    
+--    virtual_text = false,
+--    show_diagnostic_autocmds = {'InsertLeave', 'TextChanged'},
+--    diagnostic_delay = 500
+--  })
+--vim.cmd [[autocmd CursorHold * lua vim.diagnostic.open_float(0, {scope="cursor", close_events = {"CursorMoved", "CursorMovedI", "BufHidden", "InsertCharPre", "WinLeave"}})]]
+
+--function LspDiagnosticsFocus()
+--    vim.api.nvim_command('set eventignore=WinLeave')
+--    vim.api.nvim_command('autocmd CursorMoved <buffer> ++once set eventignore=""')
+--    vim.diagnostic.open_float(nil, {focusable = false, scope = 'line', close_events = {"CursorMoved", "CursorMovedI", "BufHidden", "InsertCharPre", "WinLeave"}})
+--end
+--vim.api.nvim_set_keymap('', '<Leader>a', '<Cmd>lua LspDiagnosticsFocus()<CR>', {silent = true})
+
+--local diagnostics_active = true
+--map('n', '<leader>a', function()
+--  diagnostics_active = not diagnostics_active
+--  if diagnostics_active then
+--    vim.diagnostic.show()
+--  else
+--    vim.diagnostic.hide()
+--  end
+--end)
+
+-- Global config for diagnostic
+--vim.diagnostic.config({
+--	underline = false,
+--	virtual_text = false,
+--	signs = true,
+--	severity_sort = true,
+--	float = {
+--    focusable = true, --
+--    style = "minimal", --
+--		--border = "rounded",
+--    border = "shadow",
+--		source = "always",
+--		header = "",
+--		prefix = "",
+--	},
+--})
+
+vim.lsp.handlers["textDocument/publishDiagnostics"] = vim.lsp.with(vim.lsp.diagnostic.on_publish_diagnostics, {
+	underline = true,
+	virtual_text = false,
+	signs = true,
+	update_in_insert = false,
+})
+
+--vim.lsp.buf.definition
+vim.lsp.handlers["textDocument/hover"] = vim.lsp.with(vim.lsp.handlers.hover, { border = "rounded" })
+
+--vim.lsp.handlers["textDocument/hover"] = vim.lsp.with(vim.lsp.handlers.hover, { border = "rounded" })
+
+vim.lsp.handlers["textDocument/signatureHelp"] = vim.lsp.with(vim.lsp.handlers.signature_help, { border = "rounded" })
+
+--local signs = { Error = " ", Warn = " ", Info = "􀅴 ", Hint = " " }
+--local signs = { Error = "✘", Warn = "▲", Info = "🛈 ", Hint = "⚑" }
+local signs = { Error = "✘", Warn = "▲", Info = "􀅳", Hint = "⚑" }
+for type, icon in pairs(signs) do
+	local hl = "DiagnosticSign" .. type
+	vim.fn.sign_define(hl, { text = icon, texthl = hl, numhl = "" })
+end
+
+
+---- Location information about the last message printed. The format is
+---- `(did print, buffer number, line number)`.
+--local last_echo = { false, -1, -1 }
+--
+---- The timer used for displaying a diagnostic in the commandline.
+--local echo_timer = nil
+--
+---- The timer after which to display a diagnostic in the commandline.
+--local echo_timeout = 250
+--
+---- The highlight group to use for warning messages.
+--local warning_hlgroup = 'WarningMsg'
+--
+---- The highlight group to use for error messages.
+--local error_hlgroup = 'ErrorMsg'
+--
+---- If the first diagnostic line has fewer than this many characters, also add
+---- the second line to it.
+--local short_line_limit = 20
+--
+---- Shows the current line's diagnostics in a floating window.
+--function show_line_diagnostics()
+--  vim
+--    .lsp
+--    .diagnostic
+--    .show_line_diagnostics({ severity_limit = 'Warning' }, vim.fn.bufnr(''))
+--end
+--
+---- Prints the first diagnostic for the current line.
+--function echo_diagnostic()
+--  if echo_timer then
+--    echo_timer:stop()
+--  end
+--
+--  echo_timer = vim.defer_fn(
+--    function()
+--      local line = vim.fn.line('.') - 1
+--      local bufnr = vim.api.nvim_win_get_buf(0)
+--
+--      if last_echo[1] and last_echo[2] == bufnr and last_echo[3] == line then
+--        return
+--      end
+--
+--      local diags = vim
+--        .lsp
+--        .diagnostic
+--        .get_line_diagnostics(bufnr, line, { severity_limit = 'Warning' })
+--
+--      if #diags == 0 then
+--        -- If we previously echo'd a message, clear it out by echoing an empty
+--        -- message.
+--        if last_echo[1] then
+--          last_echo = { false, -1, -1 }
+--
+--          vim.api.nvim_command('echo ""')
+--        end
+--
+--        return
+--      end
+--
+--      last_echo = { true, bufnr, line }
+--
+--      local diag = diags[1]
+--      local width = vim.api.nvim_get_option('columns') - 15
+--      local lines = vim.split(diag.message, "\n")
+--      local message = lines[1]
+--      local trimmed = false
+--
+--      if #lines > 1 and #message <= short_line_limit then
+--        message = message .. ' ' .. lines[2]
+--      end
+--
+--      if width > 0 and #message >= width then
+--        message = message:sub(1, width) .. '...'
+--      end
+--
+--      local kind = 'warning'
+--      local hlgroup = warning_hlgroup
+--
+--      if diag.severity == vim.lsp.protocol.DiagnosticSeverity.Error then
+--        kind = 'error'
+--        hlgroup = error_hlgroup
+--      end
+--
+--      local chunks = {
+--        { kind .. ': ', hlgroup },
+--        { message }
+--      }
+--
+--      vim.api.nvim_echo(chunks, false, {})
+--    end,
+--    echo_timeout
+--  )
+--end
+--vim.cmd([[
+--  autocmd CursorMoved * :lua echo_diagnostic()
+--]])
+-- Highlight line number instead of having icons in sign column
+
+-- See the properties of the signs with sign list.
+
+--vim.cmd [[
+--  highlight! DiagnosticLineNrError guibg=#51202A guifg=#FF0000 gui=bold
+--  highlight! DiagnosticLineNrWarn guibg=#51412A guifg=#FFA500 gui=bold
+--  highlight! DiagnosticLineNrInfo guibg=#1E535D guifg=#00FFFF gui=bold
+--  highlight! DiagnosticLineNrHint guibg=#1E205D guifg=#0000FF gui=bold
+--
+--  sign define DiagnosticSignError text= texthl=DiagnosticSignError linehl= numhl=DiagnosticLineNrError
+--  sign define DiagnosticSignWarn text= texthl=DiagnosticSignWarn linehl= numhl=DiagnosticLineNrWarn
+--  sign define DiagnosticSignInfo text= texthl=DiagnosticSignInfo linehl= numhl=DiagnosticLineNrInfo
+--  sign define DiagnosticSignHint text= texthl=DiagnosticSignHint linehl= numhl=DiagnosticLineNrHint
+--]]
+
+-- Highlight symbol under cursor
+
+-- Add the following to your on_attach (this allows checking server capabilities to avoid calling invalid commands.
+
+--if client.resolved_capabilities.document_highlight then
+--  vim.cmd [[
+--    hi! LspReferenceRead cterm=bold ctermbg=red guibg=LightYellow
+--    hi! LspReferenceText cterm=bold ctermbg=red guibg=LightYellow
+--    hi! LspReferenceWrite cterm=bold ctermbg=red guibg=LightYellow
+--  ]]
+--  vim.api.nvim_create_augroup('lsp_document_highlight', {
+--    clear = false
+--  })
+--  vim.api.nvim_clear_autocmds({
+--    buffer = bufnr,
+--    group = 'lsp_document_highlight',
+--  })
+--  vim.api.nvim_create_autocmd({ 'CursorHold', 'CursorHoldI' }, {
+--    group = 'lsp_document_highlight',
+--    buffer = bufnr,
+--    callback = vim.lsp.buf.document_highlight,
+--  })
+--  vim.api.nvim_create_autocmd('CursorMoved', {
+--    group = 'lsp_document_highlight',
+--    buffer = bufnr,
+--    callback = vim.lsp.buf.clear_references,
+--  })
+--end
+
diff --git a/lua/plugins/lspkind.lua b/lua/plugins/lspkind.lua
new file mode 100644
index 0000000..72ca5c2
--- /dev/null
+++ b/lua/plugins/lspkind.lua
@@ -0,0 +1,47 @@
+local status, lspkind = pcall(require, "lspkind")
+if (not status) then return end
+
+lspkind.init({
+  -- enables text annotations
+  --
+  -- default: true
+  mode = 'symbol',
+
+  -- default symbol map
+  -- can be either 'default' (requires nerd-fonts font) or
+  -- 'codicons' for codicon preset (requires vscode-codicons font)
+  --
+  -- default: 'default'
+  preset = 'codicons',
+
+  -- override preset symbols
+  --
+  -- default: {}
+  symbol_map = {
+    Text = "",
+    Method = "",
+    Function = "",
+    Constructor = "",
+    Field = "ﰠ",
+    Variable = "",
+    Class = "ﴯ",
+    Interface = "",
+    Module = "",
+    Property = "ﰠ",
+    Unit = "塞",
+    Value = "",
+    Enum = "",
+    Keyword = "",
+    Snippet = "",
+    Color = "",
+    File = "",
+    Reference = "",
+    Folder = "",
+    EnumMember = "",
+    Constant = "",
+    Struct = "פּ",
+    Event = "",
+    Operator = "",
+    TypeParameter = ""
+  },
+})
diff --git a/lua/plugins/lspsaga-22.10.23-13:08-bak.lua b/lua/plugins/lspsaga-22.10.23-13:08-bak.lua
new file mode 100644
index 0000000..0bf1ec7
--- /dev/null
+++ b/lua/plugins/lspsaga-22.10.23-13:08-bak.lua
@@ -0,0 +1,145 @@
+require "lspsaga".init_lsp_saga {
+    -- "single" | "double" | "rounded" | "bold" | "plus"
+    border_style = "rounded",
+    --border_style = "single",
+    saga_winblend = 30,
+    move_in_saga = { next = '<C-n>', prev = '<C-p>' },
+    --move_in_saga = { prev = "k", next = "j" },
+    scroll_in_preview = {
+    scroll_down = "<C-d>",
+    scroll_up = "<C-u>",
+  },
+    diagnostic_header = { " ", " ", " ", " " },
+    -- add bracket or something with diagnostic source, just have 2 elements
+    -- use emoji lightbulb in default
+    code_action_icon = "",
+    --code_action_icon = "ﯦ ",
+    -- if true can press number to execute the codeaction in codeaction window
+    code_action_num_shortcut = true,
+    -- same as nvim-lightbulb but async
+    code_action_lightbulb = {
+        enable = false,
+        sign = false,
+        sign_priority = 20, --
+        virtual_text = false,
+    },
+    finder_icons = {
+        def = "  ",
+        ref = "  ",
+        link = "  ",
+    },
+    -- preview lines of lsp_finder and definition preview
+    max_preview_lines = 5,
+    definition_action_keys = {
+        edit = '<CR>',
+        vsplit = '<C-y>',
+        split = '<C-x>',
+        tabe = '<C-t>',
+        quit = '<ESC>',
+    },
+    -- definition_preview_quit = '<ESC>',
+    -- finder_preview_hl_ns = 8,
+    finder_action_keys = {
+        open =  { 'o', '<CR>' },
+        vsplit = "v",
+        split = "s",
+        tabe = "t",
+        quit = "<ESC>",
+        scroll_down = "<C-j>",
+        scroll_up = "<C-k>", -- quit can be a table
+    },
+    code_action_keys = {
+        quit = "<ESC>",
+        exec = "<CR>",
+    },
+    rename_action_quit = "<ESC>",
+    rename_in_select = true,
+    symbol_in_winbar = {
+        enable = true,
+        --in_custom = false,
+        in_custom = true,
+        separator = '  ',
+        --show_file = false,
+        show_file = true,
+        click_support = false,
+        --click_support = false,
+    },
+    --show_outline = {
+    --    win_position = 'right',
+    --    --set special filetype win that outline window split.like NvimTree neotree
+    --    -- defx, db_ui
+    --    min_with = '',
+    --    win_width = 40,
+    --    auto_enter = false,
+    --    auto_preview = true,
+    --    virt_text = 'x',
+    --    jump_key = 'l',
+    --    -- auto refresh when change buffer
+    --    auto_refresh = true,
+    --},
+    custom_kind = {
+        File          =  { " " },
+        Module        =  { " " },
+        Namespace     =  { "ﱕ " },
+        Package       =  { " " },
+        Class         =  { "ﴯ " },
+        Method        =  { "" },
+        Property      =  { "ﰠ " },
+        Field         =  { "ﰠ " },
+        Constructor   =  { " " },
+        Enum          =  { " " },
+        Interface     =  { " " },
+        Function      =  { " " },
+        Variable      =  { " " },
+        Constant      =  { " " },
+        String        =  { " " },
+        Number        =  { " " },
+        Boolean       =  { " " },
+        Array         =  { " " },
+        Object        =  { " " },
+        Key           =  { "- " },
+        Null          =  { " " },
+        EnumMember    =  { " " },
+        Struct        =  { " " },
+        Event         =  { " " },
+        Operator      =  { " " },
+        TypeParameter =  { " " },
+        TypeAlias     =  { " " },
+        Parameter     =  { " " },
+        StaticMethod  =  { " " },
+        Macro         =  { "廓" },
+    },
+}
+
+ -- Mappings.
+local map = vim.api.nvim_set_keymap
+local opts = { noremap = true, silent = true }
+
+map("n", "gd", "<CMD>Lspsaga peek_definition<CR>", opts)
+--map("n", "gp", "<Cmd>Lspsaga peek_definition<CR>", opts)
+map("n", "gi", "<CMD>Lspsaga lsp_finder<CR>", opts)
+map("n", "gh", "<CMD>Lspsaga hover_doc<CR>", opts)
+map("n", "gs", "<CMD>Lspsaga signature_help<CR>", opts)
+map("n", "ga", "<CMD>Lspsaga code_action<CR>",             opts)
+map("v", "ga", "<CMD><C-u>Lspsaga range_code_action<CR>",  opts)
+map("n", "gl", "<CMD>Lspsaga show_line_diagnostics<CR>",   opts)
+--map("n", "go", "<CMD>Lspsaga open_floaterm zsh<CR>", opts)
+map("n", ";D", "<CMD>Lspsaga show_cursor_diagnostics<CR>", opts)
+map("n", "<gr>", "<CMD>Lspsaga rename<CR>",               opts)
+map("n", "gk", "<CMD>Lspsaga diagnostic_jump_prev<CR>", opts)
+map("n", "gj", "<CMD>Lspsaga diagnostic_jump_next<CR>", opts)
+map("n", "[d", "<Cmd>lua vim.lsp.diagnostic.goto_prev()<CR>", opts)
+map("n", "]d", "<Cmd>lua vim.lsp.diagnostic.goto_next()<CR>", opts)
+map("t", "<ESC>", "<CMD>Lspsaga close_floaterm<CR>", opts)
+
+--vim.api.nvim_command("highlight LspFloatWinNormal guibg=none ")
+--hi LspFloatWinNormal guibg=none
+
+
+-- vim.api.nvim_create_autocmd("BufEnter", {
+-- callback = function ()
+--     if #vim.api.nvim_list_wins() == 1 and vim.bo.filetype == "lspsagaoutline" then
+--     vim.cmd "quit"
+--     end
+-- end
+-- })
diff --git a/lua/plugins/lspsaga.lua b/lua/plugins/lspsaga.lua
new file mode 100644
index 0000000..4161ce9
--- /dev/null
+++ b/lua/plugins/lspsaga.lua
@@ -0,0 +1,46 @@
+return function()
+  local saga = require "lspsaga"
+
+  saga.init_lsp_saga {
+    use_saga_diagnostic_sign = false,
+    finder_action_keys = {
+      vsplit = "v",
+      split = "s",
+      quit = { "q", "<ESC>" },
+    },
+    code_action_icon = "💡",
+    code_action_prompt = {
+      enable = false,
+      sign = false,
+      virtual_text = false,
+    },
+  }
+
+  require("as.highlights").highlight("LspSagaLightbulb", { guifg = "NONE", guibg = "NONE" })
+
+--  as.vnoremap("<leader>ca", ":<c-u>lua require('lspsaga.codeaction').range_code_action()<CR>")
+--  as.inoremap("<c-k>", "<cmd>lua require('lspsaga.signaturehelp').signature_help()<CR>")
+--  as.nnoremap("K", "<cmd>lua require('lspsaga.hover').render_hover_doc()<CR>")
+--  -- scroll down hover doc
+--  as.nnoremap("<C-f>", "<cmd>lua require('lspsaga.action').smart_scroll_with_saga(1)<CR>")
+--  -- scroll up hover doc
+--  as.nnoremap("<C-b>", "<cmd>lua require('lspsaga.action').smart_scroll_with_saga(-1)<CR>")
+
+  require("which-key").register {
+    ["<leader>rn"] = { require("lspsaga.rename").rename, "lsp: rename" },
+    ["<leader>ca"] = { require("lspsaga.codeaction").code_action, "lsp: code action" },
+    ["gp"] = { require("lspsaga.provider").preview_definition, "lsp: preview definition" },
+    ["gh"] = { require("lspsaga.provider").lsp_finder, "lsp: finder" },
+    -- jump diagnostic
+    ["]c"] = { require("lspsaga.diagnostic").lsp_jump_diagnostic_prev, "lsp: previous diagnostic" },
+    ["[c"] = { require("lspsaga.diagnostic").lsp_jump_diagnostic_next, "lsp: next diagnostic" },
+  }
+
+ -- augroup("LspSagaCursorCommands", {
+ --   {
+ --     events = { "CursorHold" },
+ --     targets = { "*" },
+ --     command = "lua require('lspsaga.diagnostic').show_cursor_diagnostics()",
+ --   },
+ -- })
+end
diff --git a/lua/plugins/lualine.lua b/lua/plugins/lualine.lua
new file mode 100644
index 0000000..9d86e21
--- /dev/null
+++ b/lua/plugins/lualine.lua
@@ -0,0 +1,423 @@
+local lualine_status_ok, lualine = pcall(require, "lualine")
+if not lualine_status_ok then
+	print("lualine.nvim is etiher broken or is not installed.")
+	return
+end
+
+--local colors = require('tokyonight.colors').setup()
+--local colors = {
+--bg_dark = "#1f2335",
+--bg = "#24283b",
+--fg = "#c0caf5",
+--fg_gutter = "#3b4261",
+--green = "#a6e3a1",
+--red = "#f38ba8",
+--}
+
+--local colors = {
+--    gray       = '#23232e',
+--    lightgray  = '#5f6a8e',
+--    orange     = '#ffb86c',
+--    purple     = '#bd93f9',
+--    red        = '#ff5555',
+--    yellow     = '#f1fa8c',
+--    green      = '#50fa7b',
+--    white      = '#f8f8f2',
+--    black      = '#282a36',
+--}
+local colors = {
+	nobg = nil,
+	blue = "#87b0f9",
+	mauve = "#cba6f7",
+	red = "#f38ba8",
+	green = "#a6e3a1",
+	peach = "#fab387",
+	white = "#c6d0f5",
+	gray = "#a1a8c9",
+	black = "#1e1e2e",
+	innerbg = nil,
+	outerbg = "#16161D",
+}
+--require("lualine").setup({
+-- Your lua part of config goes here
+require("lualine").setup({
+	options = {
+		icons_enabled = true,
+		--theme = "auto",
+		theme = require("plugins.linecolor").theme(),
+		--theme = {
+		-- We are going to use lualine_c an lualine_x as left and
+		-- right section. Both are highlighte by c theme .  So we
+		-- are just setting default looks o statusline
+		--normal = { c = { fg = colors.fg, bg = colors.bg } },
+		--inactive = { c = { fg = colors.fg, bg = colors.bg } },
+		--},
+		component_separators = { left = "", right = "" },
+		section_separators = { left = "", right = "" },
+		--component_separators = { left = '|', right = '|'},
+		--section_separators = { left = '', right = ''},
+		disabled_filetypes = {
+			statusline = {},
+			winbar = {},
+		},
+		ignore_focus = {},
+		always_divide_middle = true,
+		globalstatus = true,
+		refresh = {
+			statusline = 1000,
+			tabline = 1000,
+			winbar = 1000,
+		},
+	},
+	sections = {
+		lualine_a = { "mode" },
+		lualine_b = {
+			"branch",
+			{
+				"diff",
+				colored = true,
+				diff_color = {
+					added = "DiffAdd",
+					modified = "DiffChange",
+					removed = "DiffDelete",
+				},
+			},
+			{
+				"diagnostics",
+
+				sources = { "nvim_lsp" },
+				sections = { "error", "warn", "info" },
+
+				diagnostics_color = {
+					error = "DiagnosticError",
+					warn = "DiagnosticWarn",
+					info = "DiagnosticInfo",
+				},
+				colored = true,
+				update_in_insert = false,
+				always_visible = false,
+			},
+		},
+		--lualine_b = { "branch", "diff", "diagnostics" },
+		lualine_c = {
+			--{"filetype", padding={right=0}, icon_only = true, component_separators = {left = "", right = ""}},
+			--{"filename", padding={left=0}, color = {gui = "bold,italic"}},
+			--{ "filetype",
+			--  icon_only = true,
+			--},
+			{
+				"filename",
+				--color = {gui = "bold,italic", fg = '#ffaa88', bg = 'nil' },
+				--component_separators = {left = "", right = ""},
+			},
+		},
+		lualine_x = { "encoding", "fileformat", "filetype" },
+		--lualine_x = {
+		--  {"encoding", color = { bg = colors.black }, component_separators = {left = "", right = ""}},
+		--  {"fileformat", color = { bg = colors.black }, component_separators = {left = "", right = ""}},
+		--  {"filetype", color = { bg = colors.black }, component_separators = {left = "", right = ""}},
+		--},
+		lualine_y = { "progress" },
+		lualine_z = { "location" },
+	},
+	inactive_sections = {
+		lualine_a = {},
+		lualine_b = {},
+		lualine_c = { "filename" },
+		lualine_x = { "location" },
+		lualine_y = {},
+		lualine_z = {},
+	},
+	--	tabline = {},
+	tabline = {
+		--lualine_a = { "mode" },
+		--lualine_a = {custom_fname},
+		lualine_a = {
+			{
+				"buffers",
+				show_filename_only = false,
+				show_modified_status = true,
+				mode = 4,
+				buffers_color = {
+					active = { bg = colors.nobg, fg = colors.black }, -- color for active buffer
+					--inactive = { bg = colors.white, fg = colors.fg_gutter }, -- color for inactive buffer
+					--active = { bg = colors.bg, fg = colors.white },   -- color for active buffer
+					--inactive = { bg = colors.bg_dark, fg = colors.fg_gutter }, -- color for inactive buffer
+					----color = function()
+					----  return { bg = vim.bo.modified and '#aa3355' or '#33aa88' }
+					----end,
+				},
+				symbols = {
+					modified = " ●", -- Text to show when the buffer is modified
+					alternate_file = "", -- Text to show to identify the alternate file
+					--directory = "", -- Text to show when the buffer is a directory
+				},
+				max_length = vim.o.columns * 5 / 6,
+				--{{function()
+				--  local bg = 'hi! lualine_buffers_color' -- not modified
+				--  if vim.bo.modified then bg = '#c70039' -- unsaved
+				--  elseif not vim.bo.readonly then bg = 'hi! lualine_buffers_color' end -- readonly
+				--  vim.cmd('hi! lualine_buffers_color guibg='..bg)
+				--end,
+				--color = 'hi! lualine_buffers_color',
+				--}},
+			},
+		},
+		lualine_b = {},
+		lualine_c = {},
+		lualine_x = {},
+		lualine_y = {},
+		lualine_z = {},
+		--lualine_z = { "tabs" },
+	},
+	--tabline = {
+	--  lualine_a = { "mode" },
+	--  lualine_b = { "buffers" },
+	--  lualine_c = { "branch" },
+	--  --lualine_c = { "branch", "diff", "diagnostics" },
+	--  lualine_x = {},
+	--  lualine_y = {},
+	--  lualine_z = { "tabs" },
+	--},
+	--winbar = {
+	--  lualine_a = {},
+	--  lualine_b = {},
+	--  lualine_c = {'filename'},
+	--  lualine_x = {},
+	--  lualine_y = {},
+	--  lualine_z = {}
+	--},
+	--inactive_winbar = {
+	--  lualine_a = {},
+	--  lualine_b = {},
+	--  lualine_c = {},
+	--  lualine_x = {},
+	--  lualine_y = {},
+	--  lualine_z = {}
+	--},
+	winbar = {},
+	inactive_winbar = {},
+	--extensions = {},
+	extensions = { "quickfix" },
+})
+--require("lualine").statusline()
+--require("lualine").tabline()
+--if not lualine_status_ok then
+--	print("lualine.nvim is etiher broken or is not installed.")
+--	return
+--end
+--local lualine_status_ok, lualine = pcall(require, "lualine")
+--if not lualine_status_ok then
+--  print("lualine.nvim is etiher broken or is not installed.")
+--  return
+--end
+--local utils = require("heirline.utils")
+
+--local M = {}
+
+-- stylua: ignore start
+--M.colours = {--{{{
+---- Color table for highlights
+---- stylua: ignore
+--local colors = {
+--  bg       = '#2E3440',
+--  fg       = '#E5E9F0',
+--  yellow   = '#EBCB8B',
+--  cyan     = '#88C0D0',
+--  darkblue = '#5E81AC',
+--  green    = '#A3BE8C',
+--  orange   = '#D08770',
+--  violet   = '#B48EAD',
+--  magenta  = '#B48EAD',
+--  blue     = '#81A1C1',
+--  red      = '#BF616A',
+--}
+--
+--local conditions = {
+--	buffer_not_empty = function()
+--		return vim.fn.empty(vim.fn.expand("%:t")) ~= 1
+--	end,
+--	hide_in_width = function()
+--		return vim.fn.winwidth(0) > 80
+--	end,
+--	check_git_workspace = function()
+--		local filepath = vim.fn.expand("%:p:h")
+--		local gitdir = vim.fn.finddir(".git", filepath .. ";")
+--		return gitdir and #gitdir > 0 and #gitdir < #filepath
+--	end,
+--}
+
+-- Config
+--local config = {
+--require('lualine').setup {
+--	options = {
+--		-- Disable sections and component separators
+--		component_separators = "",
+--		section_separators = "",
+--		theme = {
+--			-- We are going to use lualine_c an lualine_x as left and
+--			-- right section. Both are highlighte by c theme .  So we
+--			-- are just setting default looks o statusline
+--			normal = { c = { fg = colors.fg, bg = colors.bg } },
+--			inactive = { c = { fg = colors.fg, bg = colors.bg } },
+--		},
+--		disabled_filetypes = { "NvimTree" },
+--	},
+--	sections = {
+--		-- these are to remove the defaults
+--		lualine_a = {},
+--		lualine_b = {},
+--		lualine_y = {},
+--		lualine_z = {},
+--		-- These will be filled later
+--		lualine_c = {},
+--		lualine_x = {},
+--	},
+--	inactive_sections = {
+--		-- these are to remove the defaults
+--		lualine_a = {},
+--		lualine_b = {},
+--		lualine_y = {},
+--		lualine_z = {},
+--		lualine_c = {},
+--		lualine_x = {},
+--	},
+--}
+--
+---- Inserts a component in lualine_c at left section
+--local function ins_left(component)
+--	table.insert(lualine.sections.lualine_c, component)
+--end
+--
+---- Inserts a component in lualine_x ot right section
+--local function ins_right(component)
+--	table.insert(lualine.sections.lualine_x, component)
+--end
+--
+--ins_left({
+--	function()
+--		return "▊"
+--	end,
+--	color = { fg = colors.green }, -- Sets highlighting of component
+--	padding = { left = 0, right = 1 }, -- We don't need space before this
+--})
+--
+--ins_left({
+--	-- mode component
+--	function()
+--		return ""
+--	end,
+--	color = function()
+--		-- auto change color according to neovims mode
+--		local mode_color = {
+--			n = colors.blue,
+--			i = colors.green,
+--			v = colors.violet,
+--			["�"] = colors.blue,
+--			V = colors.blue,
+--			c = colors.magenta,
+--			no = colors.red,
+--			s = colors.orange,
+--			S = colors.orange,
+--			ic = colors.yellow,
+--			R = colors.violet,
+--			Rv = colors.violet,
+--			cv = colors.red,
+--			ce = colors.red,
+--			r = colors.cyan,
+--			rm = colors.cyan,
+--			["r?"] = colors.cyan,
+--			["!"] = colors.red,
+--			t = colors.red,
+--		}
+--		return { fg = mode_color[vim.fn.mode()] }
+--	end,
+--	padding = { right = 1 },
+--})
+--
+--ins_left({
+--	-- mode component
+--	"mode",
+--	color = function()
+--		-- auto change color according to neovims mode
+--		local mode_color = {
+--			n = colors.red,
+--			i = colors.green,
+--			v = colors.violet,
+--			["�"] = colors.blue,
+--			V = colors.blue,
+--			c = colors.magenta,
+--			no = colors.red,
+--			s = colors.orange,
+--			S = colors.orange,
+--			ic = colors.yellow,
+--			R = colors.violet,
+--			Rv = colors.violet,
+--			cv = colors.red,
+--			ce = colors.red,
+--			r = colors.cyan,
+--			rm = colors.cyan,
+--			["r?"] = colors.cyan,
+--			["!"] = colors.red,
+--			t = colors.red,
+--		}
+--		return { fg = mode_color[vim.fn.mode()] }
+--	end,
+--	padding = { right = 1 },
+--})
+--
+--ins_left({
+--	"branch",
+--	icon = "",
+--	color = { fg = colors.violet, gui = "bold" },
+--})
+--
+--ins_left({
+--	"filename",
+--	cond = conditions.buffer_not_empty,
+--	color = { fg = colors.aqua, gui = "bold" },
+--})
+--
+--ins_left({
+--	-- filesize component
+--	"filesize",
+--	cond = conditions.buffer_not_empty,
+--})
+--
+---- Add components to right sections
+--ins_right({
+--	"o:encoding", -- option component same as &encoding in viml
+--	fmt = string.lower, -- I'm not sure why it's upper case either ;)
+--	cond = conditions.hide_in_width,
+--	color = { fg = colors.yellow },
+--})
+--
+--ins_right({
+--	"fileformat",
+--	fmt = string.upper,
+--	icons_enabled = true, -- I think icons are cool but Eviline doesn't have them. sigh
+--	color = { fg = colors.fg, gui = "bold" },
+--})
+--
+--ins_right({
+--	"filetype",
+--})
+--
+--ins_right({ "progress", color = { fg = colors.fg, gui = "bold" } })
+--
+--ins_right({
+--	"location",
+--})
+--
+--ins_right({
+--	function()
+--		return "▊"
+--	end,
+--	color = { fg = colors.green },
+--	padding = { left = 1 },
+--})
+--return M
+-- Now don't forget to initialize lualine
+--require("lualine").setup(config)
+--require"lualine".setup(config)
+--lualine.setup(config)
diff --git a/lua/plugins/luasnip-22.10.23-12:54-bak.lua b/lua/plugins/luasnip-22.10.23-12:54-bak.lua
new file mode 100644
index 0000000..08f49ee
--- /dev/null
+++ b/lua/plugins/luasnip-22.10.23-12:54-bak.lua
@@ -0,0 +1,161 @@
+if vim.g.snippets ~= "luasnip" or not pcall(require, "luasnip") then
+  return
+end
+--local luasnip = require("luasnip")
+local ls = require "luasnip" --
+local types = require "luasnip.util.types" --
+--local options = {
+ls.config.set_config {
+  history = true,
+  updateevents = "TextChanged,TextChangedI",
+  -- Autosnippets:
+  enable_autosnippets = true, --
+  ext_opts = { --
+    [types.choiceNode] = { --
+      active = { --
+        virt_text = { { " « ", "NonTest" } }, --
+      }, --
+    }, --
+  }, --
+}
+
+--local keymap = vim.keymap
+local keymap = vim.api.nvim_set_keymap
+--local keymap = vim.keymap.set
+-- <c-j> is my jump backwards key.
+-- this always moves to the previous item within the snippet
+
+--keymap({ "i", "s" }, "<C-j>", function()
+-- if ls.jumpable(-1) then
+--   ls.jump(-1)
+-- end
+--end, { silent = true })
+
+-- <c-l> is selecting within a list of options.
+-- This is useful for choice nodes (introduced in the forthcoming episode 2)
+--keymap({"i"}, "<c-l>", function()
+--  if ls.choice_active() then
+--    ls.change_choice(1)
+--  end
+--end, { silent = true })
+
+
+--keymap("i", "<c-z>", require "luasnip.extras.select_choice")
+
+-- shorcut to source my luasnips file again, which will reload my snippets
+--keymap("n", "<leader><leader>s", "<cmd>source ~/.config/nvim/lua/user/plugins/luasnip.lua<CR>")
+
+-- ls.parser.parse_snippet(<text>, <VS**** style snippet>)
+--ls.snippets = {
+-- all = {
+--   -- Available in any filetype
+--   ls.parser.parse_snippet("expand", "-- this is what was expanded!"),
+--s.snippets = {
+-- all = {
+--   -- Available in any filetype
+--   ls.parser.parse_snippet("expand", "-- this is what was expanded!"),
+-- },
+-- lua = {
+--   -- Lua specific snippets go here.
+--   ls.parser.parse_snippet("lf", "local $1 = function($2)\n $0\nend")
+-- },
+--
+--})
+local snip = ls.snippet
+local node = ls.snippet_node
+local text = ls.text_node
+local insert = ls.insert_node
+local func = ls.function_node
+local choice = ls.choice_node
+local dynamicn = ls.dynamic_node
+
+local date = function() return {os.date('%Y-%m-%d')} end
+
+ls.add_snippets(nil, {
+    all = {
+        --snip({
+        --    trig = "date",
+        --    namr = "Date",
+        --    dscr = "Date in the form of YYYY-MM-DD",
+        --}, {
+        --    func(date, {}),
+        --}),
+      snip({
+    trig = "meta",
+    namr = "Metadata",
+    dscr = "Yaml metadata format for markdown"
+},
+{
+    text({"---",
+    "title: "}), insert(1, "note_title"), text({"", 
+    "author: "}), insert(2, "author"), text({"", 
+    "date: "}), func(date, {}), text({"",
+    "categories: ["}), insert(3, ""), text({"]",
+    "lastmod: "}), func(date, {}), text({"",
+    "tags: ["}), insert(4), text({"]",
+    "comments: true",
+    "---", ""}),
+    insert(0)
+  }),
+  }})
+--keymap("i", "<C-j>", "<cmd>lua require'luasnip'.jump(1)<CR>", opts)
+--keymap("s", "<C-j>", "<cmd>lua require'luasnip'.jump(1)<CR>", opts)
+--keymap("i", "<C-k>", "<cmd>lua require'luasnip'.jump(-1)<CR>", opts)
+--local opts = { noremap = true, silent = true }
+--local keymap = vim.api.nvim_set_keymap
+--local keymap = vim.keymap
+--local term_opts = { noremap = true, silent = false }
+--	local map = function(mode, l, r, opts)
+--		opts = opts or {}
+--		opts.silent = true
+--    opts.noremap = true
+--		keymap.set(mode, l, r, opts)
+--	end
+
+
+
+--keymap("i", "<C-j>", "<Plug>luasnip-expand-or-jump * <Cmd>lua require'luasnip'.expand_or_jump()<CR>", opts)
+--keymap("i", "<C-k>", "<Plug>luasnip-jump-prev * <Cmd>lua require'luasnip'.jump(-1)<CR>", opts)
+--keymap("s", "<C-j>", "<Plug>luasnip-expand-or-jump * <Cmd>lua require'luasnip'.expand_or_jump()<CR>", opts)
+--keymap("s", "<C-k>", "<Plug>luasnip-jump-prev * <Cmd>lua require'luasnip'.jump(-1)<CR>", opts)
+--keymap("i", "<C-c>", "<Plug>luasnip-next-choice * <Cmd>lua require'luasnip'.change_choice(1)<CR>", opts)
+--keymap("s", "<C-k>", "<cmd>lua require'luasnip'.jump(-1)<CR>", opts)
+--map("i", "<C-j>", "<Plug>luasnip-expand-or-jump<CR>")
+
+--!  <Plug>luasnip-expand-repeat * <Cmd>lua require'luasnip'.expand_repeat()<CR>
+--!  <Plug>luasnip-delete-check * <Cmd>lua require'luasnip'.unlink_current_if_deleted()<CR>
+--i  <Plug>luasnip-jump-prev * <Cmd>lua require'luasnip'.jump(-1)<CR>
+--i  <Plug>luasnip-jump-next * <Cmd>lua require'luasnip'.jump(1)<CR>
+--i  <Plug>luasnip-prev-choice * <Cmd>lua require'luasnip'.change_choice(-1)<CR>
+--i  <Plug>luasnip-next-choice * <Cmd>lua require'luasnip'.change_choice(1)<CR>
+--i  <Plug>luasnip-expand-snippet * <Cmd>lua require'luasnip'.expand()<CR>
+--i  <Plug>luasnip-expand-or-jump * <Cmd>lua require'luasnip'.expand_or_jump()<CR>
+
+---
+
+
+
+
+
+
+
+
+
+--luasnip.config.set_config(options)
+--require("luasnip.loaders.from_vscode").lazy_load()
+--require("luasnip.loaders.from_vscode").lazy_load { paths = vim.g.luasnippets_path or "" }
+--
+--vim.api.nvim_create_autocmd("InsertLeave", {
+--  callback = function()
+--    if
+--      require("luasnip").session.current_nodes[vim.api.nvim_get_current_buf()]
+--      and not require("luasnip").session.jump_active
+--    then
+--      require("luasnip").unlink_current()
+--    end
+--  end,
+--})
+
+
+
+
diff --git a/lua/plugins/luasnip.lua b/lua/plugins/luasnip.lua
new file mode 100644
index 0000000..de2177e
--- /dev/null
+++ b/lua/plugins/luasnip.lua
@@ -0,0 +1,69 @@
+local ls = require "luasnip" --
+
+require("luasnip.loaders.from_lua").load({ paths = "~/.config/nvim/snippets/" })
+--local options = {
+ls.config.set_config {
+  history = true,
+  updateevents = "TextChanged,TextChangedI",
+  -- Autosnippets:
+  enable_autosnippets = true, --
+  ext_opts = { --
+    [require("luasnip.util.types").choiceNode] = {
+      active = {
+        virt_text = { { "«", "GruvboxOrange" } },
+      },
+    },
+  },
+}
+
+--local keymap = vim.keymap
+--local keymap = vim.api.nvim_set_keymap
+local keymap = vim.keymap.set
+--keymap('i', '<c-f>', 'luasnip#expand_or_jumpable() ? "<Plug>luasnip-expand-or-jump" : "<Tab>"', {expr = true, silent = true})
+keymap({ "i", "s"}, "<c-f>", function()
+  if ls.expand_or_jumpable() then
+    ls.expand()
+  end
+end)
+
+keymap({ "i", "s"}, "<c-j>", function()
+  if ls.jumpable(1) then
+    ls.jump(1)
+  end
+end)
+
+keymap({ "i", "s"}, "<c-k>", function()
+  if ls.jumpable(-1) then
+    ls.jump(-1)
+  end
+end)
+
+keymap({ "i", "s"}, "<c-c>", function()
+  if ls.choice_active() then
+    ls.change_choice(1)
+  end
+end)
+
+keymap({ "i", "s"}, "<a-c>", function()
+  if ls.choice_active() then
+    ls.change_choice(-1)
+  end
+end)
+
+-- Character class	Matching
+--  %a	letters (A-Z, a-z)
+--  %c	control characters (\n, \t, \r, ...)
+--  %d	digits (0-9)
+--  %l	lower-case letter (a-z)
+--  %p	punctuation characters (!, ?, &, ...)
+--  %s	space characters
+--  %u	upper-case letters
+--  %w	alphanumeric characters (A-Z, a-z, 0-9)
+--  %x	hexadecimal digits (\3, \4, ...)
+--  %z	the character with representation 0
+--  .	  Matches any character
+
+
+
+
+
diff --git a/lua/plugins/mason.lua b/lua/plugins/mason.lua
new file mode 100644
index 0000000..69c61ba
--- /dev/null
+++ b/lua/plugins/mason.lua
@@ -0,0 +1,27 @@
+local status, mason = pcall(require, "mason")
+if (not status) then return end
+local status2, lspconfig = pcall(require, "mason-lspconfig")
+if (not status2) then return end
+
+mason.setup({
+
+})
+
+lspconfig.setup {
+  ensure_installed = { "sumneko_lua" },
+}
+local keymap = vim.api.nvim_set_keymap
+local opts = { noremap = true }
+
+
+keymap('n', 'gd', ':lua vim.lsp.buf.definition()<cr>', opts)
+keymap('n', 'gD', ':lua vim.lsp.buf.declaration()<cr>', opts)
+keymap('n', 'gi', ':lua vim.lsp.buf.implementation()<cr>', opts)
+keymap('n', 'gw', ':lua vim.lsp.buf.document_symbol()<cr>', opts)
+keymap('n', 'gw', ':lua vim.lsp.buf.workspace_symbol()<cr>', opts)
+keymap('n', 'gr', ':lua vim.lsp.buf.references()<cr>', opts)
+keymap('n', 'gt', ':lua vim.lsp.buf.type_definition()<cr>', opts)
+keymap('n', 'K', ':lua vim.lsp.buf.hover()<cr>', opts)
+keymap('n', '<c-k>', ':lua vim.lsp.buf.signature_help()<cr>', opts)
+keymap('n', '<leader>af', ':lua vim.lsp.buf.code_action()<cr>', opts)
+keymap('n', '<leader>rn', ':lua vim.lsp.buf.rename()<cr>', opts)
diff --git a/lua/plugins/modify-blend.lua b/lua/plugins/modify-blend.lua
new file mode 100644
index 0000000..7c48815
--- /dev/null
+++ b/lua/plugins/modify-blend.lua
@@ -0,0 +1,40 @@
+local ui = vim.api.nvim_list_uis()[1]
+
+local bufnr = vim.api.nvim_create_buf(false, true)
+local win = vim.api.nvim_open_win(bufnr, true, {
+  relative = "editor",
+  width = ui.width,
+  height = ui.height,
+  row = 10,
+  col = 10,
+  style = "minimal",
+})
+
+vim.api.nvim_win_set_option(win, "winblend", 1)
+
+local blend_start = 15
+local offset = 1
+
+CANCEL = false
+local timer = vim.loop.new_timer()
+timer:start(
+  0,
+  50,
+  vim.schedule_wrap(function()
+    blend_start = blend_start + offset
+
+    if blend_start > 90 then
+      offset = -1
+    elseif blend_start < 10 then
+      offset = 1
+    end
+
+    if CANCEL or not vim.api.nvim_win_is_valid(win) then
+      timer:close()
+      timer:stop()
+      return
+    end
+
+    vim.cmd([[highlight NormalFloat blend=]] .. tostring(blend_start))
+  end)
+)
diff --git a/lua/plugins/neoscroll.lua b/lua/plugins/neoscroll.lua
new file mode 100644
index 0000000..d122584
--- /dev/null
+++ b/lua/plugins/neoscroll.lua
@@ -0,0 +1,21 @@
+require("neoscroll").setup({
+	easing_function = "quadratic",
+})
+
+local t = {}
+-- Syntax: t[keys] = {function, {function arguments}}
+-- Use the "sine" easing function
+t["<C-u>"] = { "scroll", { "-vim.wo.scroll", "true", "20", [['cubic']] } }
+t["<C-d>"] = { "scroll", { "vim.wo.scroll", "true", "20", [['cubic']] } }
+-- Use the "circular" easing function
+t["<C-b>"] = { "scroll", { "-vim.api.nvim_win_get_height(0)", "true", "50", [['cubic']] } }
+t["<C-f>"] = { "scroll", { "vim.api.nvim_win_get_height(0)", "true", "50", [['cubic']] } }
+-- Pass "nil" to disable the easing animation (constant scrolling speed)
+t["<C-y>"] = { "scroll", { "-0.10", "false", "100", nil } }
+t["<C-e>"] = { "scroll", { "0.10", "false", "100", nil } }
+-- When no easing function is provided the default easing function (in this case "quadratic") will be used
+t["zt"] = { "zt", { "10" } }
+t["zz"] = { "zz", { "10" } }
+t["zb"] = { "zb", { "10" } }
+
+require("neoscroll.config").set_mappings(t)
diff --git a/lua/plugins/null-ls.lua b/lua/plugins/null-ls.lua
new file mode 100644
index 0000000..7fc4377
--- /dev/null
+++ b/lua/plugins/null-ls.lua
@@ -0,0 +1,26 @@
+local null_ls_status_ok, null_ls = pcall(require, "null-ls")
+if not null_ls_status_ok then
+	return
+end
+
+-- https://github.com/jose-elias-alvarez/null-ls.nvim/tree/main/lua/null-ls/builtins/formatting
+local formatting = null_ls.builtins.formatting
+-- https://github.com/jose-elias-alvarez/null-ls.nvim/tree/main/lua/null-ls/builtins/diagnostics
+local diagnostics = null_ls.builtins.diagnostics
+
+--null_ls.setup({
+--	debug = false,
+--	sources = {
+--		formatting.prettier.with({ extra_args = { "--no-semi", "--single-quote", "--jsx-single-quote" } }),
+--		formatting.black.with({ extra_args = { "--fast" } }),
+--		formatting.stylua,
+--    -- diagnostics.flake8
+--	},
+--})
+require("null-ls").setup({
+	sources = {
+		require("null-ls").builtins.formatting.stylua,
+		require("null-ls").builtins.diagnostics.eslint,
+		require("null-ls").builtins.completion.spell,
+	},
+})
diff --git a/lua/plugins/nvim-tree.lua b/lua/plugins/nvim-tree.lua
new file mode 100644
index 0000000..a1e10e0
--- /dev/null
+++ b/lua/plugins/nvim-tree.lua
@@ -0,0 +1,69 @@
+local status_ok, nvim_tree = pcall(require, "nvim-tree")
+if not status_ok then
+  return
+end
+
+local config_status_ok, nvim_tree_config = pcall(require, "nvim-tree.config")
+if not config_status_ok then
+  return
+end
+
+local tree_cb = nvim_tree_config.nvim_tree_callback
+
+nvim_tree.setup({
+  update_focused_file = {
+    enable = true,
+    update_cwd = true,
+  },
+  renderer = {
+    root_folder_modifier = ":t",
+    icons = {
+      glyphs = {
+        default = "",
+        symlink = "",
+        folder = {
+          arrow_open = "",
+          arrow_closed = "",
+          default = "",
+          open = "",
+          empty = "",
+          empty_open = "",
+          symlink = "",
+          symlink_open = "",
+        },
+        git = {
+          unstaged = "",
+          staged = "S",
+          unmerged = "",
+          renamed = "➜",
+          untracked = "U",
+          deleted = "",
+          ignored = "◌",
+        },
+      },
+    },
+  },
+  diagnostics = {
+    enable = true,
+    show_on_dirs = true,
+    icons = {
+      hint = "",
+      info = "",
+      warning = "",
+      error = "",
+    },
+  },
+  view = {
+    width = 30,
+    --height = 30,
+    side = "left",
+    mappings = {
+      list = {
+        { key = { "l", "<CR>", "o" }, cb = tree_cb("edit") },
+        { key = "h", cb = tree_cb("close_node") },
+        { key = "v", cb = tree_cb("vsplit") },
+        { key = "u", action = "dir_up" },
+      },
+    },
+  },
+})
diff --git a/lua/plugins/prettier.lua b/lua/plugins/prettier.lua
new file mode 100644
index 0000000..05d4665
--- /dev/null
+++ b/lua/plugins/prettier.lua
@@ -0,0 +1,19 @@
+local status, prettier = pcall(require, "prettier")
+if (not status) then return end
+
+prettier.setup {
+  bin = 'prettierd',
+  filetypes = {
+    "c",
+    "lua",
+    "vim",
+    --"css",
+    --"javascript",
+    --"javascriptreact",
+    --"typescript",
+    --"typescriptreact",
+    --"json",
+    --"scss",
+    "less"
+  }
+}
diff --git a/lua/plugins/scripts/lsp-ext.lua b/lua/plugins/scripts/lsp-ext.lua
new file mode 100644
index 0000000..c4378c6
--- /dev/null
+++ b/lua/plugins/scripts/lsp-ext.lua
@@ -0,0 +1,48 @@
+--
+-- lsp-ext.lua
+
+
+M = {}
+
+function M.preview_location(location, context, before_context)
+    -- location may be LocationLink or Location (more useful for the former)
+    context = context or 15
+    before_context = before_context or 0
+    local uri = location.targetUri or location.uri
+    if uri == nil then
+        return
+    end
+    local bufnr = vim.uri_to_bufnr(uri)
+    if not vim.api.nvim_buf_is_loaded(bufnr) then
+        vim.fn.bufload(bufnr)
+    end
+    local range = location.targetRange or location.range
+    local contents =
+        vim.api.nvim_buf_get_lines(bufnr, range.start.line - before_context, range["end"].line + 1 + context, false)
+    local filetype = vim.api.nvim_buf_get_option(bufnr, "filetype")
+    return vim.lsp.util.open_floating_preview(contents, filetype)
+end
+
+function M.preview_location_callback(_, method, result)
+    local context = 15
+    if result == nil or vim.tbl_isempty(result) then
+        print("No location found: " .. method)
+        return nil
+    end
+    if vim.tbl_islist(result) then
+        M.floating_buf, M.floating_win = M.preview_location(result[1], context)
+    else
+        M.floating_buf, M.floating_win = M.preview_location(result, context)
+    end
+end
+
+function M.peek_definition()
+    if vim.tbl_contains(vim.api.nvim_list_wins(), M.floating_win) then
+        vim.api.nvim_set_current_win(M.floating_win)
+    else
+        local params = vim.lsp.util.make_position_params()
+        return vim.lsp.buf_request(0, "textDocument/definition", params, M.preview_location_callback)
+    end
+end
+
+return M
diff --git a/lua/plugins/scripts/setcolors.lua b/lua/plugins/scripts/setcolors.lua
new file mode 100644
index 0000000..605bc84
--- /dev/null
+++ b/lua/plugins/scripts/setcolors.lua
@@ -0,0 +1,121 @@
+vim.cmd([[
+" Change the color scheme from a list of color scheme names.
+" Version 2010-09-12 from http://vim.wikia.com/wiki/VimTip341
+" Press key:
+"   F8                next scheme
+"   Shift-F8          previous scheme
+"   Alt-F8            random scheme
+" Set the list of color schemes used by the above (default is 'all'):
+"   :SetColors all              (all $VIMRUNTIME/colors/*.vim)
+"   :SetColors my               (names built into script)
+"   :SetColors blue ayu ron   (these schemes)
+"   :SetColors                  (display current scheme names)
+" Set the current color scheme based on time of day:
+"   :SetColors now
+if v:version < 700 || exists('loaded_setcolors') || &cp
+  finish
+endif
+
+let loaded_setcolors = 1
+let s:mycolors = ['everblush', 'ayu', 'gruvbox', 'molokai', 'onedark', 'srcery']  " colorscheme names that we use to set color
+
+" Set list of color scheme names that we will use, except
+" argument 'now' actually changes the current color scheme.
+function! s:SetColors(args)
+  if len(a:args) == 0
+    echo 'Current color scheme names:'
+    let i = 0
+    while i < len(s:mycolors)
+      echo '  '.join(map(s:mycolors[i : i+4], 'printf("%-14s", v:val)'))
+      let i += 5
+    endwhile
+  elseif a:args == 'all'
+    let paths = split(globpath(&runtimepath, 'colors/*.vim'), "\n")
+    let s:mycolors = uniq(sort(map(paths, 'fnamemodify(v:val, ":t:r")')))
+    echo 'List of colors set from all installed color schemes'
+  elseif a:args == 'my'
+    let c1 = 'default srcery everblush'
+    let c2 = 'gruvbox onedark'
+    let c3 = 'ayu molokai'
+    let s:mycolors = split(c1.' '.c2.' '.c3)
+    echo 'List of colors set from built-in names'
+  elseif a:args == 'now'
+    call s:HourColor()
+  else
+    let s:mycolors = split(a:args)
+    echo 'List of colors set from argument (space-separated names)'
+  endif
+endfunction
+
+command! -nargs=* SetColors call s:SetColors('<args>')
+
+" Set next/previous/random (how = 1/-1/0) color from our list of colors.
+" The 'random' index is actually set from the current time in seconds.
+" Global (no 's:') so can easily call from command line.
+function! NextColor(how)
+  call s:NextColor(a:how, 1)
+endfunction
+
+" Helper function for NextColor(), allows echoing of the color name to be
+" disabled.
+function! s:NextColor(how, echo_color)
+  if len(s:mycolors) == 0
+    call s:SetColors('all')
+  endif
+  if exists('g:colors_name')
+    let current = index(s:mycolors, g:colors_name)
+  else
+    let current = -1
+  endif
+  let missing = []
+  let how = a:how
+  for i in range(len(s:mycolors))
+    if how == 0
+      let current = localtime() % len(s:mycolors)
+      let how = 1  " in case random color does not exist
+    else
+      let current += how
+      if !(0 <= current && current < len(s:mycolors))
+        let current = (how>0 ? 0 : len(s:mycolors)-1)
+      endif
+    endif
+    try
+      execute 'colorscheme '.s:mycolors[current]
+      break
+    catch /E185:/
+      call add(missing, s:mycolors[current])
+    endtry
+  endfor
+  redraw
+  if len(missing) > 0
+    echo 'Error: colorscheme not found:' join(missing)
+  endif
+  if (a:echo_color)
+    echo g:colors_name
+  endif
+endfunction
+
+nnoremap <leader>cn :call NextColor(1)<CR>
+nnoremap <leader>cp :call NextColor(-1)<CR>
+nnoremap <leader>cc :call NextColor(0)<CR>
+
+" Set color scheme according to current time of day.
+function! s:HourColor()
+  let hr = str2nr(strftime('%H'))
+  if hr <= 3
+    let i = 0
+  elseif hr <= 7
+    let i = 1
+  elseif hr <= 14
+    let i = 2
+  elseif hr <= 18
+    let i = 3
+  else
+    let i = 4
+  endif
+  let nowcolors = 'srcery onedark molokai'
+  execute 'colorscheme '.split(nowcolors)[i]
+  redraw
+  echo g:colors_name
+endfunction
+]])
diff --git a/lua/plugins/scripts/toggleLsp.lua b/lua/plugins/scripts/toggleLsp.lua
new file mode 100644
index 0000000..28af698
--- /dev/null
+++ b/lua/plugins/scripts/toggleLsp.lua
@@ -0,0 +1,40 @@
+local M = {}
+
+local check_function = function(bufnr, _)
+    local ok, result = pcall(vim.api.nvim_buf_get_var, bufnr, 'lsp_enabled')
+    -- No buffer local variable set, so just enable by default
+    if not ok then
+        return true
+    end
+
+    return result
+end
+
+vim.lsp.handlers["textDocument/publishDiagnostics"] =
+    vim.lsp.with(vim.lsp.diagnostic.on_publish_diagnostics, {
+        underline = check_function,
+        virtual_text = check_function,
+        signs = check_function
+    })
+
+function M.Enable()
+  vim.b.lsp_enabled = true
+end
+
+function M.Disable()
+  vim.b.lsp_enabled = false
+end
+
+function M.Toggle()
+    if vim.b.lsp_enabled == false then
+        M.Enable()
+    else
+        M.Disable()
+    end
+end
+
+vim.cmd [[
+  command! -nargs=* ToggleLsp lua require'lsp.toggle'.Toggle()
+]]
+
+return M
diff --git a/lua/plugins/telescope.lua b/lua/plugins/telescope.lua
new file mode 100644
index 0000000..db065d7
--- /dev/null
+++ b/lua/plugins/telescope.lua
@@ -0,0 +1,223 @@
+local status_ok, telescope = pcall(require, "telescope")
+if not status_ok then
+	return
+end
+local actions = require("telescope.actions")
+local builtin = require("telescope.builtin")
+
+local function telescope_buffer_dir()
+	return vim.fn.expand("%:p:h")
+end
+
+telescope.load_extension("fzf")
+telescope.load_extension("file_browser")
+require("telescope").load_extension("file_browser")
+local fb_actions = require("telescope").extensions.file_browser.actions
+--telescope.load_extension('media_files')
+
+telescope.setup({
+	defaults = {
+		--
+		prompt_prefix = " ",
+		selection_caret = " ",
+		path_display = { "smart" },
+		--
+		mappings = {
+			i = {
+				["<C-n>"] = actions.cycle_history_next,
+				["<C-p>"] = actions.cycle_history_prev,
+
+				["<C-j>"] = actions.move_selection_next,
+				["<C-k>"] = actions.move_selection_previous,
+
+				["<C-c>"] = actions.close,
+
+				["<Down>"] = actions.move_selection_next,
+				["<Up>"] = actions.move_selection_previous,
+
+				["<CR>"] = actions.select_default,
+				["<C-x>"] = actions.select_horizontal,
+				["<C-y>"] = actions.select_vertical,
+				["<C-t>"] = actions.select_tab,
+
+				["<C-u>"] = actions.preview_scrolling_up,
+				["<C-d>"] = actions.preview_scrolling_down,
+
+				["<PageUp>"] = actions.results_scrolling_up,
+				["<PageDown>"] = actions.results_scrolling_down,
+
+				["<Tab>"] = actions.toggle_selection + actions.move_selection_worse,
+				["<S-Tab>"] = actions.toggle_selection + actions.move_selection_better,
+				["<C-q>"] = actions.send_to_qflist + actions.open_qflist,
+				["<M-q>"] = actions.send_selected_to_qflist + actions.open_qflist,
+				["<C-l>"] = actions.complete_tag,
+				["<C-_>"] = actions.which_key, -- keys from pressing <C-/>
+			},
+
+			n = {
+				["<esc>"] = actions.close,
+				["<CR>"] = actions.select_default,
+				["<C-x>"] = actions.select_horizontal,
+				["<C-v>"] = actions.select_vertical,
+				["<C-t>"] = actions.select_tab,
+
+				["<Tab>"] = actions.toggle_selection + actions.move_selection_worse,
+				["<S-Tab>"] = actions.toggle_selection + actions.move_selection_better,
+				["<C-q>"] = actions.send_to_qflist + actions.open_qflist,
+				["<M-q>"] = actions.send_selected_to_qflist + actions.open_qflist,
+
+				["j"] = actions.move_selection_next,
+				["k"] = actions.move_selection_previous,
+				["H"] = actions.move_to_top,
+				["M"] = actions.move_to_middle,
+				["L"] = actions.move_to_bottom,
+
+				["<Down>"] = actions.move_selection_next,
+				["<Up>"] = actions.move_selection_previous,
+				["gg"] = actions.move_to_top,
+				["G"] = actions.move_to_bottom,
+
+				["<C-u>"] = actions.preview_scrolling_up,
+				["<C-d>"] = actions.preview_scrolling_down,
+
+				["<PageUp>"] = actions.results_scrolling_up,
+				["<PageDown>"] = actions.results_scrolling_down,
+
+				["?"] = actions.which_key,
+				["cd"] = function(prompt_bufnr)
+					local selection = require("telescope.actions.state").get_selected_entry()
+					local dir = vim.fn.fnamemodify(selection.path, ":p:h")
+					require("telescope.actions").close(prompt_bufnr)
+					-- Depending on what you want put `cd`, `lcd`, `tcd`
+					vim.cmd(string.format("silent lcd %s", dir))
+				end,
+			},
+		},
+	},
+	pickers = {
+		-- Default configuration for builtin pickers goes here:
+		-- picker_name = {
+		--   picker_config_key = value,
+		--   ...
+		-- }
+		-- Now the picker_config_key will be applied every time you call this
+		-- builtin picker
+	},
+	extensions = {
+		file_browser = {
+			theme = "dropdown",
+			-- disables netrw and use telescope-file-browser in its place
+			hijack_netrw = true,
+			mappings = {
+				-- your custom insert mode mappings
+				["i"] = {
+					["<C-w>"] = function()
+						vim.cmd("normal vbd")
+					end,
+				},
+				["n"] = {
+					-- your custom normal mode mappings
+					["N"] = fb_actions.create,
+					["h"] = fb_actions.goto_parent_dir,
+					["/"] = function()
+						vim.cmd("startinsert")
+					end,
+				},
+			},
+		},
+
+		media_files = {
+			-- filetypes whitelist
+			-- defaults to {"png", "jpg", "mp4", "webm", "pdf"}
+			filetypes = { "png", "webp", "jpg", "jpeg" },
+			find_cmd = "rg", -- find command (defaults to `fd`)
+		},
+		-- Your extension configuration goes here:
+		-- extension_name = {
+		--   extension_config_key = value,
+		-- }
+		-- please take a look at the readme of the extension you want to configure
+	},
+})
+
+telescope.load_extension("file_browser")
+
+--vim.keymap.set("n", ";f", function()
+--	builtin.find_files({
+--		no_ignore = false,
+--		hidden = true,
+--	})
+--end)
+vim.keymap.set("n", ";r", function()
+	builtin.live_grep()
+end)
+vim.keymap.set("n", "\\\\", function()
+	builtin.buffers()
+end)
+vim.keymap.set("n", ";t", function()
+	builtin.help_tags()
+end)
+vim.keymap.set("n", ";;", function()
+	builtin.resume()
+end)
+vim.keymap.set("n", ";e", function()
+	builtin.diagnostics()
+end)
+--vim.keymap.set("n", "sf", function()
+--	telescope.extensions.file_browser.file_browser({
+--		path = "%:p:h",
+--		cwd = telescope_buffer_dir(),
+--		respect_gitignore = false,
+--		hidden = true,
+--		grouped = true,
+--		previewer = false,
+--		initial_mode = "normal",
+--		layout_config = { height = 40 },
+--	})
+--end)
+
+local M = {}
+
+function M.reload()
+  local function get_module_name(s)
+    local module_name;
+
+    module_name = s:gsub("%.lua", "")
+    module_name = module_name:gsub("%/", ".")
+    module_name = module_name:gsub("%.init", "")
+
+    return module_name
+  end
+
+  local prompt_title = "~ neovim modules ~"
+
+  -- sets the path to the lua folder
+  local path = "~/.config/nvim/lua"
+
+  local opts = {
+    prompt_title = prompt_title,
+    cwd = path,
+
+    attach_mappings = function(_, map)
+     -- Adds a new map to ctrl+e.
+      map("i", "<c-e>", function(_)
+        -- these two a very self-explanatory
+        local entry = require("telescope.actions.state").get_selected_entry()
+        local name = get_module_name(entry.value)
+
+        -- call the helper method to reload the module
+        -- and give some feedback
+        R(name)
+        P(name .. " RELOADED!!!")
+      end)
+
+      return true
+    end
+  }
+
+  -- call the builtin method to list files
+  require('telescope.builtin').find_files(opts)
+end
+
+return M;
+
diff --git a/lua/plugins/toggleterm.lua b/lua/plugins/toggleterm.lua
new file mode 100644
index 0000000..912729a
--- /dev/null
+++ b/lua/plugins/toggleterm.lua
@@ -0,0 +1,90 @@
+local status_ok, toggleterm = pcall(require, "toggleterm")
+if not status_ok then
+	return
+end
+
+toggleterm.setup({
+	size = function(term)
+		if term.direction == "horizontal" then
+			return 12
+		elseif term.direction == "vertical" then
+			return vim.o.columns * 0.3
+		end
+	end,
+	--size = 20,
+	open_mapping = [[<leader>to]],
+	hide_numbers = true,
+	shade_filetypes = {},
+	shade_terminals = false,
+	shading_factor = 1,
+	start_in_insert = true,
+	insert_mappings = true,
+	persist_size = true,
+	direction = "float",
+	--direction = "vertical",
+	--direction = "horizontal",
+	close_on_exit = true,
+	shell = vim.o.shell,
+	highlights = {
+		-- highlights which map to a highlight group name and a table of it's values
+		-- NOTE: this is only a subset of values, any group placed here will be set for the terminal window split
+		Normal = {
+			background = "#000000",
+		},
+	},
+	float_opts = {
+		width = 70,
+		height = 15,
+		winblend = 3,
+		border = "curved",
+		--winblend = 0,
+		highlights = {
+			border = "Normal",
+			background = "Normal",
+		},
+	},
+})
+
+function _G.set_terminal_keymaps()
+	local opts = { noremap = true }
+	--local opts = {buffer = 0}
+	vim.api.nvim_buf_set_keymap(0, "t", "<esc>", [[<C-\><C-n>]], opts)
+	vim.api.nvim_buf_set_keymap(0, "t", "jj", [[<C-\><C-n>]], opts)
+	vim.api.nvim_buf_set_keymap(0, "t", "<C-h>", [[<C-\><C-n><C-W>h]], opts)
+	vim.api.nvim_buf_set_keymap(0, "t", "<C-j>", [[<C-\><C-n><C-W>j]], opts)
+	vim.api.nvim_buf_set_keymap(0, "t", "<C-k>", [[<C-\><C-n><C-W>k]], opts)
+	vim.api.nvim_buf_set_keymap(0, "t", "<C-l>", [[<C-\><C-n><C-W>l]], opts)
+end
+
+vim.cmd("autocmd! TermOpen term://* lua set_terminal_keymaps()")
+
+local Terminal = require("toggleterm.terminal").Terminal
+local lazygit = Terminal:new({ cmd = "lazygit", hidden = true })
+
+function _LAZYGIT_TOGGLE()
+	lazygit:toggle()
+end
+
+local node = Terminal:new({ cmd = "node", hidden = true })
+
+function _NODE_TOGGLE()
+	node:toggle()
+end
+
+local ncdu = Terminal:new({ cmd = "ncdu", hidden = true })
+
+function _NCDU_TOGGLE()
+	ncdu:toggle()
+end
+
+local htop = Terminal:new({ cmd = "htop", hidden = true })
+
+function _HTOP_TOGGLE()
+	htop:toggle()
+end
+
+local python = Terminal:new({ cmd = "python", hidden = true })
+
+function _PYTHON_TOGGLE()
+	python:toggle()
+end
diff --git a/lua/plugins/treesitter.lua b/lua/plugins/treesitter.lua
new file mode 100644
index 0000000..b081ca3
--- /dev/null
+++ b/lua/plugins/treesitter.lua
@@ -0,0 +1,34 @@
+local status, treesitter = pcall(require, "nvim-treesitter.configs")
+if (not status) then return end
+
+treesitter.setup {
+  highlight = {
+    enable = true,
+    disable = {},
+  },
+  indent = {
+    enable = true,
+    disable = {},
+    --disable = { "python", "css" }
+  },
+  ensure_installed = {
+    "c",
+    "bash",
+    "lua",
+    "rust",
+  },
+  --ensure_installed = "all", -- one of "all" or a list of languages
+  --ignore_install = { "" }, -- List of parsers to ignore installing
+  autotag = {
+    enable = true,
+  },
+  efactor = {
+    highlight_definitions = { enable = true },
+    highlight_current_scope = { enable = true }
+  }
+}
+--vim.opt.foldmethod = "expr"
+--vim.opt.foldexpr = "nvim_treesitter#foldexpr()"
+
+--local parser_config = require "nvim-treesitter.parsers".get_parser_configs()
+--parser_config.tsx.filetype_to_parsername = { "javascript", "typescript.tsx" }
diff --git a/lua/plugins/web-devicons.lua b/lua/plugins/web-devicons.lua
new file mode 100644
index 0000000..b8396bc
--- /dev/null
+++ b/lua/plugins/web-devicons.lua
@@ -0,0 +1,12 @@
+local status, icons = pcall(require, "nvim-web-devicons")
+if (not status) then return end
+
+icons.setup {
+  -- your personnal icons can go here (to override)
+  -- DevIcon will be appended to `name`
+  override = {
+  },
+  -- globally enable default icons (default to false)
+  -- will get overriden by `get_icons` option
+  default = true
+}
diff --git a/lua/plugins/zen-mode.lua b/lua/plugins/zen-mode.lua
new file mode 100644
index 0000000..7e52854
--- /dev/null
+++ b/lua/plugins/zen-mode.lua
@@ -0,0 +1,7 @@
+local status, zenMode = pcall(require, "zen-mode")
+if (not status) then return end
+
+zenMode.setup {
+}
+
+vim.keymap.set('n', '<C-w>o', '<cmd>ZenMode<cr>', { silent = true })