# rebuild nixos config to apply nvim theme
        print "Rebuilding nixos config to apply nvim theme... (this may take a moment)"

        # rebuild nixos config to apply themes
        print "Rebuilding nixos config to apply themes... (this may take a moment)"

vim.o.tabstop = 4
vim.o.shiftwidth = 4
vim.o.softtabstop = 4
vim.o.expandtab = true -- for nicer indentation
vim.api.nvim_set_hl(0, "Number", { fg = "#ff0000" })

vim.o.tabstop = 4
vim.o.shiftwidth = 4
vim.o.softtabstop = 4
vim.o.expandtab = true -- for nicer indentation
vim.api.nvim_set_hl(0, "Number", { fg = "#ff0000" })

vim.o.textwidth = 72
vim.o.colorcolumn = "50"

vim.o.textwidth = 72
vim.o.colorcolumn = "50"

vim.o.tabstop = 4
vim.o.shiftwidth = 4
vim.o.softtabstop = 4
vim.o.textwidth = 80

vim.o.tabstop = 4
vim.o.shiftwidth = 4
vim.o.softtabstop = 4
vim.o.expandtab = true -- for nicer indentation
vim.api.nvim_set_hl(0, "Number", { fg = "#ff0000" })

vim.o.shiftwidth = 2
vim.o.softtabstop = 2
vim.o.tabstop = 2
vim.o.expandtab = true

local bufnr = vim.api.nvim_get_current_buf()
vim.keymap.set("n", "ga", function()
	vim.cmd.RustLsp("codeAction") -- supports rust-analyzer's grouping
end, { silent = true, buffer = bufnr })
vim.keymap.set(
	"n",
	"K", -- Override Neovim's built-in hover keymap with rustaceanvim's hover actions
	function()
		vim.cmd.RustLsp({ "hover", "actions" })
	end,
	{ silent = true, buffer = bufnr }
)
vim.o.tabstop = 4
vim.o.shiftwidth = 4
vim.o.softtabstop = 4

{ lib, ... }:
let
in
{
    # initial lua config for whitespace highlighting
}
  programs.nvf.settings.vim.luaConfigRC.whitespace = "
    vim.api.nvim_create_autocmd('ColorScheme', {
      pattern = '*',
      callback = function()
        vim.api.nvim_set_hl(0, 'ws', { bg = 'red' })
      end
    })
    vim.api.nvim_set_hl(0, 'ws', { bg = 'red' })
    vim.fn.matchadd('ws', [[\(\s\|\r\)\+$]])
  ";
          end
        end
      '';
    }
  ];
  programs.nvf.settings.vim.autocmds = [
    {
      desc     = "clear trailing whitespace matches on insert enter";
      event    = [ "InsertEnter" ];
      callback = mkLuaInline ''function() vim.fn.clearmatches() end'';
    }
    {
      desc     = "highlight trailing whitespace on insert leave";
      event    = [ "InsertLeave" ];
      callback = mkLuaInline ''function() vim.fn.matchadd("ws", [[\(\s\|\r\)\+$]]) end'';
    }
    {
      desc     = "highlight yanked text";
      event    = [ "TextYankPost" ];
      callback = mkLuaInline ''function() vim.highlight.on_yank({ higroup = "Visual", timeout = 500 }) end'';
    }
    {
      desc     = "auto-resize windows on vim resize";
      event    = [ "VimResized" ];
      pattern  = [ "*" ];
      callback = mkLuaInline ''function() vim.cmd("wincmd =") end'';
    }
    {
      desc     = "remove trailing whitespace on save";
      event    = [ "BufWritePre" ];
      pattern  = [ "*" ];
      callback = mkLuaInline ''
        function()
          local cursor_pos = vim.api.nvim_win_get_cursor(0)
          vim.cmd("%s/\\(\\s\\|\\r\\)\\+$//e")
          vim.api.nvim_win_set_cursor(0, cursor_pos)
        end
      '';
    }
    {
      desc     = "detect fasm vs nasm by format directive";
      event    = [ "BufRead" "BufNewFile" ];
      pattern  = [ "*.asm" "*.inc" "*.j" ];
      callback = mkLuaInline ''
        function()
          local lines = vim.api.nvim_buf_get_lines(0, 0, 40, false)
          local content = table.concat(lines, "\n")
          if content:match("format ELF64 executable 3") then
            vim.bo.filetype = "fasm"
            vim.o.shiftwidth = 4
            vim.o.tabstop = 4
            vim.o.softtabstop = 4
            vim.o.expandtab = true -- for nicer indentation
          else
            vim.bo.filetype = "nasm"
            vim.o.shiftwidth = 4
            vim.o.tabstop = 4
            vim.o.softtabstop = 4
            vim.o.expandtab = true -- for nicer indentation
  inherit (lib) mkLuaInline;

{ pkgs, ... }:
{
  home.packages = [
    pkgs.vscode-extensions.vadimcn.vscode-lldb.adapter
    pkgs.vscode-js-debug
  ];
  programs.nvf.settings.vim.lazy.plugins = {
    "nvim-dap" = {
      package = pkgs.vimPlugins.nvim-dap;
      lazy = true;
      after = ''
      '';
    };
    "nvim-dap-ui" = {
      package = pkgs.vimPlugins.nvim-dap-ui;
      lazy = true;
      setupModule = "dapui";
      setupOpts = {
        controls.enabled = false;
        layouts = [
          {
            elements = [
            ];
            position = "right";
          }
          {
            elements = [
            ];
            size = 10;
            position = "bottom";
          }
        ];
      };
      # fix statusline for dap-ui widgets
      after = ''
        vim.o.statusline="%f"
        vim.api.nvim_set_hl(0, "StatusLineNC", { link = "StatusLine" })
      '';
    };
  };
}
    # cant get it working well in nasm at least
    "nvim-dap-virtual-text" = {
      package = pkgs.vimPlugins.nvim-dap-virtual-text;
      enabled = true;
      lazy = true;
      setupModule = "nvim-dap-virtual-text";
      setupOpts = {
        enabled = true;
        enabled_commands = true;
        highlight_new_as_changed = true;
        commented = true;
        virt_text_win_col = 80;
      };
      after = ''
    };
        require("nvim-dap-virtual-text").setup({
          enabled = true;
          enabled_commands = true;
          highlight_new_as_changed = true;
          commented = true;
          virt_text_win_col = 80;
        })
      '';
              {
                id = "repl";
                size = 0.5;
              }
              {
                id = "console";
                size = 0.5;
              }
            size = 71;
              {
                id = "scopes";
                size = 0.25;
              }
              {
                id = "breakpoints";
                size = 0.25;
              }
              {
                id = "stacks";
                size = 0.25;
              }
              {
                id = "watches";
                size = 0.25;
              }
                        if suffix then
                            dapui.elements.watches.add(word .. suffix)
                            print('Added: ' .. word .. suffix)
                        else
                            print('Invalid format: ' .. char)
                        end
                    end
                end)
            else
                print('No word under cursor')
            end
        end, { desc = 'Add specific single LLDB formatted watch' })
                vim.ui.input({
                    prompt = 'Format for "' .. word .. '" - ' .. help_text .. ': ',
                    default = ""
                }, function(input)
                    if input and input ~= "" then
                        local char = input:sub(1, 1):lower()
                        local suffix = formats[char]
                local help_text = '(d)ecimal (c)haracter (u)nsigned (b)inary he(x) (o)ctal (f)loat (p)ointer (s)tring b(y)tes b(Y)tes+ASCII'
                -- Format options - key maps to suffix
                local formats = {
                    d = ',d',  -- (d)ecimal
                    c = ',c',  -- (c)haracter
                    u = ',u',  -- (u)nsigned
                    b = ',b',  -- (b)inary
                    x = ',x',  -- he(x)
                    o = ',o',  -- (o)ctal
                    f = ',f',  -- (f)loat
                    p = ',p',  -- (p)ointer
                    s = ',s',  -- (s)tring
                    y = ',y',  -- b(y)tes
                    Y = ',Y',  -- b(Y)tes+ASCII
                }
                }
                local help_text = '(d)ecimal (c)haracter (u)nsigned (b)inary he(x) (o)ctal (f)loat (p)ointer (s)tring b(y)tes b(Y)tes+ASCII'
                vim.ui.input({
                    prompt = 'Format for "' .. word .. '" - ' .. help_text .. ': ',
                    default = ""
                }, function(input)
                    if input and input ~= "" then
                        local char = input:sub(1, 1):lower()
                        local suffix = formats[char]
                        if suffix then
                            dapui.elements.watches.add(word .. suffix)
                            print('Added: ' .. word .. suffix)
                        else
                            print('Invalid format: ' .. char)
                        end
                    end
                end)
            else
                print('No word under cursor')
            end
        end, { desc = 'Add specific single LLDB formatted watch' })
        vim.keymap.set('n', '<F9>', function()
            local word = vim.fn.expand('<cword>')
            if word and word ~= "" then
                local dapui = require('dapui')
        vim.keymap.set('n', '<leader>da', function()
            local word = vim.fn.expand('<cword>')
            if word and word ~= "" then
                local dapui = require('dapui')
                dapui.elements.watches.add(word)
            end
        end, { desc = 'Add default single LLDB formatted watch' })
        vim.keymap.set('n', '<F8>', function()
            local word = vim.fn.expand('<cword>')
            if word and word ~= "" then
                local dapui = require('dapui')
                dapui.elements.watches.add(word)
            end
        end, { desc = 'Add default single LLDB formatted watch' })
        vim.keymap.set('n', '<leader>dA', function()
            local word = vim.fn.expand('<cword>')
            if word and word ~= "" then
                local dapui = require('dapui')
                -- Format options - key maps to suffix
                local formats = {
                    d = ',d',  -- (d)ecimal
                    c = ',c',  -- (c)haracter
                    u = ',u',  -- (u)nsigned
                    b = ',b',  -- (b)inary
                    x = ',x',  -- he(x)
                    o = ',o',  -- (o)ctal
                    f = ',f',  -- (f)loat
                    p = ',p',  -- (p)ointer
                    s = ',s',  -- (s)tring
                    y = ',y',  -- b(y)tes
                    Y = ',Y',  -- b(Y)tes+ASCII
        -- open dapui on debugger start
        dap.listeners.before.attach.dapui_config = function()
          require("dapui").open()
        end
        dap.listeners.before.launch.dapui_config = function()
          require("dapui").open()
        end
        dap.configurations.rust = {
          {
            name = 'Launch file',
            type = 'codelldb',
            request = 'launch',
            program = function()
              return vim.fn.input('Path to executable: ', vim.fn.getcwd() .. '/', 'file')
            end,
            cwd = vim.fn.getcwd(),
            stopOnEntry = false,
          }
        }
        dap.configurations.javascript = {
          {
            type = "pwa-node",
            request = "launch",
            name = "Launch File",
            program = "''${file}",
            cwd = "''${workspaceFolder}",
          }
        }
        dap.configurations.typescript = {
          {
            type = "pwa-node",
            request = "launch",
            name = "Launch File",
            program = "''${workspaceFolder}/../node_modules/astro/astro.js",
            args = { "dev" },
            cwd = "''${workspaceFolder}",
            rootPath = "''${workspaceFolder}",
            sourceMaps = true,
            console = "integratedTerminal",
            outFiles = {
              "''${workspaceFolder}/dist/**/*.js",
              "''${workspaceFolder}/.astro/**/*.ts"
            },
            resolveSourceMapLocations = {
              "''${workspaceFolder}/dist/**/*.js",
              "''${workspaceFolder}/.astro/**/*.ts"
            },
            skipFiles = {
              "<node_internals>/**"
            }
          }
        }
        dap.configurations.astro = dap.configurations.typescript
                vim.fn.system('mkdir -p ' .. file_dir .. '/target')
                -- assemble
                vim.fn.system('nasm -f elf64 -g -F dwarf ' .. file_dir .. source .. ' -o ' .. file_dir .. '/target/' .. file .. '.o')
                -- link
                vim.fn.system('ld ' .. file_dir .. '/target/' .. file .. '.o -o ' .. file_dir .. '/target/' .. file)
                -- path to exec
                return file_dir .. '/target/' .. source
            end,
            cwd = vim.fn.expand('%:p:h'),
            stopOnEntry = true,
            terminal = "integrated",
            initCommands = {
                "settings set target.x86-disassembly-flavor intel",
            },
            -- showDisassembly = "never",
            presentationHint = "normal",
            sourceLanguages = { "asm" },
          }
        }
        local dap = require('dap')
        dap.defaults.codelldb.stepping_granularity = 'instruction'
        dap.adapters.codelldb = {
          type = 'executable',
          command = 'codelldb',
        }
        dap.adapters.gdb = {
          type = 'executable',
          command = 'gdb',
          args = { '-i', 'dap' }
        }
        dap.adapters["pwa-node"] = {
            type = "server",
            host = "localhost",
            port = "''${port}",
            executable = {
              command = "js-debug",
              args = {
                "''${port}"
              }
            },
            processId = require("dap.utils").pick_process,
        }
        -- only for nasm
        dap.configurations.nasm = {
          {
            name = "Launch NASM (CodeLLDB)",
            type = "codelldb",
            request = "launch",
            program = function()
                local file_dir = vim.fn.expand('%:p:h') -- dir of current file
                local file = vim.fn.expand('%:t') -- filename without extension
                local source = vim.fn.expand('%:t:r') -- filename with extension
    pkgs.gdb

}
{ lib, ... }: {
		|> lib.remove ./default.nix;
  imports = lib.collectNix ./.

let
  inherit (lib) enabled;
  home.packages = [
    pkgs.nodePackages.prettier
    pkgs.prettierd
    pkgs.ruff
    pkgs.sleek
  ];
      };
      format_after_save.async = true;
    };
  };
}
  programs.nvf.settings.vim.formatter.conform-nvim = enabled {
    setupOpts = {
      formatters_by_ft = {
        json     = [ "prettierd" "prettier" ];
        vue      = [ "prettierd" "prettier" ];
        yaml     = [ "prettierd" "prettier" ];
        markdown = [ "mdformat" ];
        toml     = [ "taplo" ];
        sql      = [ "sleek" ];
        python   = [ "ruff_format" ];
      formatters.mdformat.append_args = ["--number" "--wrap" "80"];
    pkgs.taplo
    pkgs.mdformat
    pkgs.alejandra
in {
{ pkgs, lib, ... }:

		end
		end
				return ""
			end
		end
	'';
}
    vim.api.nvim_create_user_command("TD", OpenTodo, { desc = "Open ~/notes/todo.md" })
    function OpenTodo() vim.cmd("edit ~/notes/todo.md") end
			if fe == "" or ff == "" then
				return ""
			elseif fe ~= "utf-8" and ff ~= "unix" then
				return fe .. " :: " .. ff .. " :: "
			elseif fe ~= "utf-8" and ff == "unix" then
				return fe .. " :: "
			elseif fe == "utf-8" and ff ~= "unix" then
				return ff .. " :: "
			else
		function LualineFileInfo()
			local fe = vim.o.fileencoding
			local ff = vim.o.fileformat
		function ToggleDirbuf()
			if vim.bo.filetype == "dirbuf" then
				vim.cmd("DirbufQuit")
			else
				vim.cmd("Dirbuf")
			end
		end
			vim.api.nvim_set_hl(0, "DiffText", {
				fg = "#1e1e1e",
				bg = "#98c379",
			})
		end
			vim.api.nvim_set_hl(0, "DiffTextAdd", {
				fg = "#1e1e1e",
				bg = "#98c379",
			})
			vim.api.nvim_set_hl(0, "DiffAdded", {
				fg = "#1e1e1e",
				bg = "#98c379",
			})
		function FixRusticated()
			vim.api.nvim_set_hl(0, "DiffAdd", {
				fg = "#1e1e1e",
				bg = "#98c379",
			})
			for group, opts in pairs(highlights) do
				vim.api.nvim_set_hl(0, group, opts)
			end
		end
		function FixRasmus()
			local highlights = {
				SpellBad = { undercurl = false, underline = true },
				SpellCap = { undercurl = false, underline = true },
				SpellLocal = { undercurl = false, underline = true },
				SpellRare = { undercurl = false, underline = true },
				DiffAdd = { reverse = false },
				DiffChange = { reverse = false },
				DiffDelete = { reverse = false },
			}
			for group, opts in pairs(highlights) do
				vim.api.nvim_set_hl(0, group, opts)
			end
		end
		function DisableUndercurl()
			local highlights = {
				DiagnosticUnderlineError = { undercurl = false, underline = true },
				DiagnosticUnderlineWarn = { undercurl = false, underline = true },
				DiagnosticUnderlineInfo = { undercurl = false, underline = true },
				DiagnosticUnderlineHint = { undercurl = false, underline = true },
			}
			for key, hl_group in pairs(hl_groups) do
				if hl_group.bold then
					vim.api.nvim_set_hl(0, key, vim.tbl_extend("force", hl_group, { bold = false }))
				end
			end
		function DisableBold()
			local hl_groups = vim.api.nvim_get_hl(0, {})
			for key, hl_group in pairs(hl_groups) do
				if hl_group.italic then
					vim.api.nvim_set_hl(0, key, vim.tbl_extend("force", hl_group, { italic = false }))
				end
			end
		function DisableItalic()
			local hl_groups = vim.api.nvim_get_hl(0, {})
			-- fixes for colorschemes
			if color == "rusticated" then
				FixRusticated()
			end
			if color == "rasmus" then
				FixRasmus()
			end
			if color == "gruvbox-material" and theme == "light" then
				vim.api.nvim_set_hl(0, "LineNrAbove", { fg = "#7C6F64", bold = true })
				vim.api.nvim_set_hl(0, "LineNrBelow", { fg = "#7C6F64", bold = true })
				vim.api.nvim_set_hl(0, "LineNr", { fg = "#4f3829", bold = true })
			end
		end
			vim.api.nvim_set_hl(0, "LspInlayHint", { fg = "#808080" })
			if theme == "dark" then
				vim.api.nvim_set_hl(0, "LineNrAbove", { fg = "#BFBFBF", bold = false })
				vim.api.nvim_set_hl(0, "LineNr", { fg = "white", bold = true })
				vim.api.nvim_set_hl(0, "LineNrBelow", { fg = "#BFBFBF", bold = false })
			end
			-- general tweaks
			if transparent then
				vim.api.nvim_set_hl(0, "Normal", { bg = "none" })
				vim.api.nvim_set_hl(0, "NormalFloat", { bg = "none" })
				vim.api.nvim_set_hl(0, "NormalNC", { bg = "none" })
			end
		-- Global functions
		function ColorMyPencils(color, theme, transparent)
			vim.o.background = theme or "light"
			vim.cmd.colorscheme(color or "default")
			require("fidget").notify("background: " .. vim.o.background .. "\n theme: " .. theme .. "\n colorscheme: " .. color)
{
	programs.nvf.settings.vim.luaConfigRC.globals = ''

{ lib, ... }:
let
in
{
    {
      event = [ "LspAttach" ];
      callback = mkLuaInline ''
        function(args)
          local client = vim.lsp.get_client_by_id(args.data.client_id)
            else
            end
          end
}
          vim.keymap.set("n", "grn", function()
            vim.lsp.buf.rename()
          end, { desc = "vim.lsp rename" })
          vim.keymap.set("n", "gi", function()
            vim.lsp.buf.implementation()
          end, { desc = "vim.lsp implementation" })
          vim.keymap.set({ "n", "v" }, "ga", function()
            vim.lsp.buf.code_action()
          end, { desc = "vim.lsp code action" })
          vim.keymap.set("n", "K", function()
            vim.lsp.buf.hover()
          end, { desc = "Hover" })
        end
      '';
    }
  ];
          end)
          if client:supports_method("textDocument/foldingRange") then
            vim.wo.foldmethod = "expr"
            vim.wo.foldexpr = "v:lua.vim.lsp.foldexpr()"
          else
            vim.wo.foldmethod = "indent"
              vim.lsp.inlay_hint.enable(true)
          vim.keymap.set("n", "<leader>ih", function()
            if vim.lsp.inlay_hint.is_enabled() then
              vim.lsp.inlay_hint.enable(false)
  programs.nvf.settings.vim.autocmds = [
  programs.nvf.settings.vim.keymaps = [
    # debugging
    {
      desc   = "toggle breakpoint";
      key    = "<leader>db";
      mode   = "n";
      action = ":lua require('dap').toggle_breakpoint()<CR>";
    }
    {
      desc   = "toggle breakpoint";
      key    = "<F1>";
      mode   = "n";
      action = ":lua require('dap').toggle_breakpoint()<CR>";
    }
    {
      desc   = "run last";
      key    = "<leader>dB";
      mode   = "n";
      action = ":lua require('dap').toggle_breakpoint(vim.fn.input('Breakpoint condition: '))<CR>";
    }
    {
      desc   = "run last";
      key    = "<F2>";
      mode   = "n";
      action = ":lua require('dap').toggle_breakpoint(vim.fn.input('Breakpoint condition: '))<CR>";
    }
    {
      desc   = "continue";
      key    = "<leader>dc";
      mode   = "n";
      action = ":lua require('dap').continue()<CR>";
    }
    {
      desc   = "continue";
      key    = "<F3>";
      mode   = "n";
      action = ":lua require('dap').continue()<CR>";
    }
    {
      desc   = "open/close debugger ui";
      key    = "<leader>du";
      mode   = "n";
      action = ":lua require('dapui').toggle()<CR>";
    }
    {
      desc   = "open/close debugger ui";
      key    = "<F4>";
      mode   = "n";
      action = ":lua require('dapui').toggle()<CR>";
    }
    {
      desc   = "step over";
      key    = "<leader>do";
      mode   = "n";
      action = ":lua require('dap').step_over()<CR>";
    }
    {
      desc   = "step over";
      key    = "<RIGHT>";
      mode   = "n";
      action = ":lua require('dap').step_over()<CR>";
    }
    {
      desc   = "step into";
      key    = "<leader>di";
      mode   = "n";
      action = ":lua require('dap').step_into()<CR>";
    }
    {
      desc   = "step into";
      key    = "<DOWN>";
      mode   = "n";
      action = ":lua require('dap').step_into()<CR>";
    }
    {
      desc   = "step out";
      key    = "<leader>dO";
      mode   = "n";
      action = ":lua require('dap').step_out()<CR>";
    }
    {
      desc   = "step out";
      key    = "<UP>";
      mode   = "n";
      action = ":lua require('dap').step_out()<CR>";
    }
    {
      desc   = "step back";
      key    = "<leader>dp";
      mode   = "n";
      action = ":lua require('dap').step_back()<CR>";
    }
    {
      desc   = "step back";
      key    = "<LEFT>";
      mode   = "n";
      action = ":lua require('dap').step_back()<CR>";
    }
    {
      desc   = "restart last session";
      key    = "<leader>dr";
      mode   = "n";
      action = ":lua require('dap').run_last()<CR>";
    }
    {
      desc   = "restart last session";
      key    = "<F5>";
      mode   = "n";
      action = ":lua require('dap').run_last()<CR>";
    }
    # clipboard mappings (thanks primeagen)
    {
      desc   = "paste over text but keep clipboard";
      key    = "<leader>p";
      mode   = "x";
      action = ''"_dP'';
    }
    {
      desc   = "yank selection to system clipboard";
      key    = "<leader>y";
      mode   = [ "n" "v" ];
      action = ''"+y'';
    }
    {
      desc   = "yank line to system clipboard";
      key    = "<leader>Y";
      mode   = "n";
      action = ''"+Y'';
    }
    {
      desc   = "delete without yank";
      key    = "<leader>d";
      mode   = [ "n" "v" ];
      action = ''"_d'';
    }
    {
      desc   = "better line joins";
      key    = "J";
      mode   = "n";
      action = "mzJ`z";
    }
    {
      desc   = "move line down";
      key    = "J";
      mode   = "v";
      action = ":m '>+1<CR>gv=gv";
    }
    {
      desc   = "move line up";
      key    = "K";
      mode   = "v";
      action = ":m '<-2<CR>gv=gv";
    }
    {
      desc   = "instant search and replace current word";
      mode   = "n";
      key    = "<leader>sr";
      action = '':%s/\<<C-r><C-w>\>/<C-r><C-w>/gI<Left><Left><Left>'';
    }
    {
      desc   = "1/2 page down + center cursor";
      key    = "<C-d>";
      mode   = "n";
      action = "<C-d>zz";
    }
    {
      desc   = "1/2 page up + center cursor";
      key    = "<C-u>";
      mode   = "n";
      action = "<C-u>zz";
    }
    {
      desc   = "center cursor on next search result";
      key    = "n";
      mode   = "n";
      action = "nzz";
    }
    {
      desc   = "center cursor on previous search result";
      key    = "N";
      mode   = "n";
      action = "Nzz";
    }
    {
      desc   = "1/2 page down + center cursor";
      key    = "<C-d>";
      mode   = "v";
      action = "<C-d>zz";
    }
    {
      desc   = "1/2 page up + center cursor";
      key    = "<C-u>";
      mode   = "v";
      action = "<C-u>zz";
    }
    {
      desc   = "center cursor on next search result";
      key    = "n";
      mode   = "v";
      action = "nzz";
    }
    {
      desc   = "center cursor on previous search result";
      key    = "N";
      mode   = "v";
      action = "Nzz";
    }
    {
      desc   = "move to first non-blank character of line";
      key    = "H";
      mode   = "n";
      action = "^";
    }
    {
      desc   = "move to last character of line";
      key    = "L";
      mode   = "n";
      action = "$";
    }
    {
      desc   = "switch to left pane";
      key    = "<C-h>";
      mode   = "n";
      action = "<C-w>h";
    }
    {
      desc   = "switch to below pane";
      key    = "<C-j>";
      mode   = "n";
      action = "<C-w>j";
    }
    {
      desc   = "switch to above pane";
      key    = "<C-k>";
      mode   = "n";
      action = "<C-w>k";
    }
    {
      desc   = "switch to right pane";
      key    = "<C-l>";
      mode   = "n";
      action = "<C-w>l";
    }
    {
      desc   = "open a terminal in a vertical split";
      key    = "<leader>tt";
      mode   = "n";
      action = "<cmd>vs<cr><cmd>term<cr>";
    }
    {
      desc   = "close window";
      key    = "<leader>qq";
      mode   = "n";
      action = "<cmd>clo<cr>";
    }
    {
      desc   = "disable search highlight";
      key    = "<leader><esc><esc>";
      mode   = "n";
      action = "<cmd>silent nohl<cr>";
    }
    # missing from builtin ccc
    {
      desc   = "Toggle ccc";
      key    = "<leader>ccc";
      mode   = "n";
      action = "<cmd>CccHighlighterToggle<CR>";
    }
    # missing from builtin mini.bufremove
    {
      desc   = "close buffer";
      key    = "<leader>qb";
      mode   = "n";
      action = "<cmd>lua MiniBufremove.delete()<CR>";
    }
    # telescope
    {
      desc   = "Telescope word";
      key    = "<leader>fw";
      mode   = "n";
      action = "<cmd>lua require('telescope.builtin').grep_string({ search = vim.fn.expand('<cword>') })<CR>";
    }
    {
      desc   = "Telescope WORD";
      key    = "<leader>fW";
      mode   = "n";
      action = "<cmd>lua require('telescope.builtin').grep_string({ search = vim.fn.expand('<cWORD>') })<CR>";
    }
    {
      desc   = "Telescope search for input word";
      key    = "<leader>fs";
      mode   = "n";
      action = "<cmd>lua require('telescope.builtin').grep_string({ search = vim.fn.input('Grep > ') })<CR>";
    }
    # missing from builtin undotree
    {
      desc   = "Toggle undotree";
      key    = "<leader>u";
      mode   = "n";
      action = "<cmd>UndotreeToggle<CR>";
    }
    {
      desc   = "Open ~/notes/todo.md";
      key    = "<leader>td";
      mode   = "n";
      action = "<cmd>lua OpenTodo()<CR>";
    }
  ];
  inherit (lib) mkLuaInline;

let
in
  inherit (lib) enabled disabled mkLuaInline;
{
  programs.nvf.settings.vim = {
      };
      "yamlls" = {
          };
        };
    };
  };
}
      };
          schemas = mkLuaInline ''require("schemastore").yaml.schemas()'';
        settings.yaml = {
          # You must disable built-in schemaStore support if you want to use
          # this plugin and its advanced options like `ignore`.
          schemaStore = disabled {
            # Avoid TypeError: Cannot read properties of undefined (reading 'length')
            url = "";
        filetypes     = [ "yaml" ];
          };
        };
      };
    };
    #============#
    # TREESITTER #
    #============#
      grammars = with pkgs.vimPlugins.nvim-treesitter.builtGrammars; [
      ];
      textobjects = enabled;
      autotagHtml = true;
        setupOpts = {
          max_lines = 3;
          separator = "▁";
        };
      };
    };
    #============#
    # OTHER LSPs #
    #============#
      context     = enabled {
      fold        = true;
      indent      = enabled;
      highlight   = enabled;
        typescript # needed manually for astro hl
        vim json vimdoc
        http nasm asm
        astro      # needed manually for astro hl
    treesitter = enabled {
          file_types = [ "markdown" "md" ];
          overrides.buftype.nofile = {
            render_modes       = true;
            link.enabled       = false;
            heading.enabled    = false;
            code.language_icon = false;
            code.language_name = false;
            code.language_info = false;
          completions.blink.enabled = true;
          sign.enabled = false;
      extensions.render-markdown-nvim = enabled {
        setupOpts = {
          enabled = false; # off by default
    languages.markdown = enabled {
      lsp = enabled;
    languages.go = enabled {
      lsp         = enabled;
      dap         = enabled;
      format.type = "gofumpt";
    };
    languages.yaml = enabled; # lsp handled in ./langs.nix
    languages.tailwind = enabled {
      lsp = enabled;
    };
    languages.svelte = enabled {
      lsp         = enabled;
      format.type = "prettier";
    };
    lsp.servers = {
      "*" = {
        root_markers = [ ".git" ];
      };
      json_ls = {
        };
        settings.json = {
          validate = enabled;
          schema   = mkLuaInline ''require("schemastore").json.schemas()'';
        filetypes     = [ "json" "jsonc" ];
      # too inconsistent right now
      # bacon-ls = {
      #   };
      # };
      #   root_markers = [ "Cargo.toml" "Cargo.lock" ".bacon-locations" ];
      #   filetypes    = [ "rust" ];
      #   cmd          = [ "bacon-ls" ];
      #   settings.init_options = {
      #     locationsFile        = ".bacon-locations";
      #     runBaconInBackground = true;
      #     updateOnSave         = true;
      #     updateOnSaveWaitMillis            = 100;
      #     synchronizeAllOpenFilesWaitMillis = 1000;
        capabilities = mkLuaInline ''
          vim.tbl_deep_extend(
            "force",
            {},
            vim.lsp.protocol.make_client_capabilities(),
            require("blink.cmp").get_lsp_capabilities()
          )
        '';
    languages.nu = enabled {
      lsp = enabled;
    };
    };
    #==============#
    # LANG SUPPORT #
    #==============#
      };
      };
      };
    };
      format = disabled {
        # prefer to manually format for configs
        type = "alejandra";
    languages.nix = enabled {
      lsp    = enabled {
        server = "nixd";
    languages.lua = enabled {
      lsp = enabled;
    };
      format.type = "prettierd";
    };
    languages.enableFormat     = true; # enable formatters for all enabled langs
    languages.enableTreesitter = true; # enable treesitter for all enabled langs
    languages.html = enabled;
    languages.css = enabled {
      lsp         = enabled;
      format.type = "prettierd";
    };
    languages.rust = enabled {
      dap        = enabled;
    # lsp handled by rustacean.vim
      crates     = enabled;
    };
    languages.assembly = enabled {
      lsp = enabled;
    };
    languages.astro = enabled {
      lsp         = enabled;
      format.type = "prettierd";
    };
    languages.ts = enabled {
      lsp   = enabled {
        server = "denols";
      };
    };
            },
          },
        }
      '';
      dap = { };
            hover = {
              actions = {
                references = {
                  enable = true,
                },
              },
            },
            interpret = {
              tests = true,
            },
            cargo = {
              features = "all",
            },
            completion = {
              hideDeprecated = true,
              fullFunctionSignatures = {
                enable = true,
              },
              callable = {
                snippets = "add_parentheses",
              },
            },
    globals.rustaceanvim = {
      tools.test_executor = "background";
      server.default_settings = mkLuaInline ''
        {
          ["rust-analyzer"] = {
            assist = {
              preferSelf = true,
            },
            -- checkOnSave and diagnostics must be disabled for bacon-ls
            diagnostics = {
              enable = true,
              experimental = {
                enable = true,
              },
              styleLints = {
                enable = true,
              },
            checkOnSave = {
              command = "clippy",
            },
      config = {
        update_in_insert = false;
        virtual_text     = false;
        float.focusable  = false;
        float.source     = "always";
        float.header     = "";
        float.prefix     = "";
    diagnostics = enabled {
  home.packages = [
    pkgs.vscode-json-languageserver
    pkgs.yaml-language-server
  ];
{ lib, pkgs, ... }:

{
	programs.nvf.settings.vim.luaConfigRC.lsp = ''
		local lsp = vim.lsp
		lsp.set_log_level("off")
		local orig_util_open_floating_preview = lsp.util.open_floating_preview
		function lsp.util.open_floating_preview(contents, syntax, opts, ...)
			opts = opts or {}
			opts.max_width = opts.max_width or 60
			opts.focusable = opts.focusable or false
			return orig_util_open_floating_preview(contents, syntax, opts, ...)
		end
		-- trying tiny-inline-diagnostic.nvim for a while
		-- vim.api.nvim_create_autocmd("CursorHold", {
		-- 	callback = function()
		-- 		vim.diagnostic.open_float()
		-- 	end,
		-- })
		local function reload_lsp()
			vim.cmd("lua vim.lsp.stop_client(vim.lsp.get_clients())")
			local function check_and_reload()
				if not lsp.buf_is_attached(0) then
					vim.cmd.edit()
				else
					vim.defer_fn(check_and_reload, 50)
				end
			end
			vim.defer_fn(check_and_reload, 50)
		end
		vim.api.nvim_create_user_command("LspReload", reload_lsp, { desc = "Reload attached LSP" })
	'';
}

let
  inherit (lib) enabled;
in
{
  programs.nvf.settings.vim = {
    globals = {
      vimwiki_option_diary_path = "./diary/";
      vimwiki_option_nested_syntaxes = {
        typescript = "ts";
      };
      vimwiki_list = [
        {
          syntax = "markdown";
        }
        {
          syntax = "markdown";
        }
      ];
    };
    lazy.plugins = {
      "rustaceanvim" = {
        package = pkgs.vimPlugins.rustaceanvim;
        lazy = false;
      };
      "dirbuf.nvim" = {
        package = pkgs.vimPlugins.dirbuf-nvim;
        cmd = "Dirbuf";
        setupModule = "dirbuf";
        setupOpts = {
          sort_order = "directories_first";
          write_cmd = "DirbufSync -confirm";
          show_hidden = true;
        };
        keys = [
          {
            mode = "n";
            key = "-";
            action = ":Dirbuf<CR>";
            desc = "Open dirbuf";
          }
          {
            mode = "n";
            key = "<C-s>";
            action = ":lua ToggleDirbuf()<CR>";
            desc = "Open dirbuf";
          }
        ];
      };
      "vimplugin-scrolleof.nvim" = {
        package = pkgs.vimUtils.buildVimPlugin {
          name = "scrolleof.nvim";
          src = pkgs.fetchFromGitHub {
            owner = "Aasim-A";
            repo = "scrollEOF.nvim";
            sha256 = "sha256-hHoS5WgIsbuVEOUbUBpDRxIwdNoR/cAfD+hlBWzaxug=";
          };
        };
        lazy = true;
        setupModule = "scrollEOF";
        setupOpts = { };
      };
      "tiny-inline-diagnostic.nvim" = {
        package = pkgs.vimPlugins.tiny-inline-diagnostic-nvim;
        setupModule = "tiny-inline-diagnostic";
        priority = 1000;
        lazy = false;
        setupOpts = {
          preset = "minimal";
          transparent_bg = true;
          transparent_cursorline = false;
          signs = {
            arrow = "";
            up_arrow = "";
          };
          options = {
            multilines = {
              enabled = true;
              always_show = true;
            };
            throttle = 100;
          };
        };
      };
      "package-info.nvim" = {
        package = pkgs.vimPlugins.package-info-nvim;
        lazy = true;
        setupModule = "package-info";
        setupOpts = {
          autostart = true;
          hide_unstable_versions = true;
          notifications = false;
            style = {
              up_to_date = "   ";
              outdated = "   ";
              invalid = "   ";
            };
          };
        };
        after = ''
          vim.api.nvim_set_hl(0, "PackageInfoUpToDateVersion", { fg = "#3c4048" })
          vim.api.nvim_set_hl(0, "PackageInfoOutdatedVersion", { fg = "#d19a66" })
          vim.api.nvim_set_hl(0, "PackageInfoInvalidVersion", { fg = "#ee4b2b" })
          vim.cmd("lua require('package-info').show({ force = true })")
        '';
      };
      "nui.nvim" = {
        package = pkgs.vimPlugins.nui-nvim;
        lazy = true;
      };
      "ts-comments.nvim" = {
        package = pkgs.vimPlugins.ts-comments-nvim;
        lazy = true;
      };
      "vimwiki" = {
        package = pkgs.vimPlugins.vimwiki;
        lazy = true;
        keys = [
          {
            mode = "n";
            key = "<leader>ww";
            action = "<Plug>VimwikiIndex";
            desc = "Open vimwiki index";
          }
          {
            mode = "n";
            key = "<leader>wi";
            action = "<Plug>VimwikiDiaryIndex";
            desc = "Open vimwiki diary";
          }
        ];
      };
      "vimplugin-quicksnip.vim" = {
        package = pkgs.vimUtils.buildVimPlugin {
          name = "quicksnip.vim";
          src = pkgs.fetchFromGitHub {
            owner = "jamesukiyo";
            repo = "quicksnip.vim";
            rev = "5b9ccd6937f1172817c5e3054ec58d7f5281b94d";
            sha256 = "sha256-QMLEqx6PH4m0c0eYhLspjGin+UrdgwcV7a/MzfRPMtM=";
          };
        };
        cmd = [
          "SnipCurrent"
          "SnipPick"
        ];
        keys = [
          {
            mode = "n";
            key = "<leader>sp";
            action = ":SnipPick<CR>";
            desc = "Pick snippet";
          }
          {
            mode = "n";
            key = "<leader>sc";
            action = ":SnipCurrent<CR>";
            desc = "Current snippet";
          }
        ];
        beforeAll = ''
          vim.g.miniSnip_trigger = "<C-c>"
          vim.g.miniSnip_extends = {
            html = { "html", "javascript" },
            svelte = { "html", "javascript" },
            javascript = { "html" },
            typescript = { "html", "javascript" }
          }
        '';
      };
      "vimplugin-minisnip" = {
        package = pkgs.vimUtils.buildVimPlugin {
          name = "minisnip";
          src = pkgs.fetchFromGitHub {
            owner = "Jorenar";
            repo = "miniSnip";
            rev = "79d863e1f8d5313ea36d045c3c067a55f3814ecd";
            sha256 = "sha256-OkF1COC3FykTYd3P/WpRAS0n0nxAPPazOytr698+6TI=";
          };
        };
        lazy = true;
      };
      "vimplugin-darklight.nvim" = {
        package = pkgs.vimUtils.buildVimPlugin {
          name = "darklight.nvim";
          src = pkgs.fetchFromGitHub {
            owner = "eliseshaffer";
            repo = "darklight.nvim";
            sha256 = "sha256-/MdGhcZ0kQsAzDl02lJK4zMf/5fC5Md0iuvWrz0ZR6Q=";
          };
        };
        lazy = true;
        setupModule = "darklight";
        setupOpts = {
          mode = "custom";
        };
      };
      "vimplugin-compile-mode.nvim" = {
        package = pkgs.vimUtils.buildVimPlugin {
          name = "compile-mode.nvim";
          src = pkgs.fetchFromGitHub {
            owner = "ej-shafran";
            repo = "compile-mode.nvim";
            sha256 = "sha256-T2l/lEOiO+X5TfAT1mcsyg307nktT+YxxlpbCloNLp4=";
          };
          doCheck = false;
        };
        cmd = [ "Compile" ];
        keys = [
          {
            mode = "n";
            key = "<leader>co";
            action = ":vert Compile<cr>";
            desc = "Compile";
          }
          {
            mode = "n";
            key = "<leader>cr";
            action = ":vert Recompile<cr>";
            desc = "Recompile";
          }
        ];
        beforeAll = ''
          vim.g.compile_mode = {
            baleia_setup = true,
            default_command = "",
            recompile_no_fail = true
          }
        '';
      };
      "plenary.nvim" = {
        package = pkgs.vimPlugins.plenary-nvim;
        lazy = true;
      };
      "baleia.nvim" = {
        package = pkgs.vimPlugins.baleia-nvim;
        lazy = true;
      };
    };
  };
}
			"lazyjj.nvim" = {
				package = pkgs.vimPlugins.lazyjj-nvim;
				lazy = true;
				setupModule = "lazyjj";
				keys = [
					{
						mode = "n";
						key = "<leader>jj";
						action = "<CMD>LazyJJ<CR>";
					}
				];
			};
      };
      "smear-cursor.nvim" = {
        package = pkgs.vimPlugins.smear-cursor-nvim;
        lazy = false;
        setupModule = "smear_cursor";
        setupOpts = {
          stiffness = 0.8;
          damping = 0.95;
          distance_stop_animating = 0.5;
          smear_between_buffers = true;
          smear_between_neighbor_lines = true;
          scroll_buffer_space = true;
          legacy_computing_symbols_support = false;
          smear_insert_mode = false;
          smear_to_cmd = false;
        };
      };
      "fff.nvim" = {
        package = fff-nvim.packages.${pkgs.system}.fff-nvim;
				lazy = true;
				setupModule = "fff";
				setupOpts = {
					debug.enabled     = false;
					debug.show_scores = false;
					title  = "fff";
					prompt = " ";
					max_results = 1000;
					max_threads = 10;
					layout.prompt_position = "top";
					layout.preview_size    = 0.6;
					preview.show_file_info = false;
					hl.normal      = "Normal";
					hl.title       = "Normal";
					hl.border      = "Grey";
					hl.active_file = "TelescopeSelection";
					hl.cursor      = "Cursor";
				};
        keys = [
          {
            mode = "n";
            key = "<leader>ff";
            action = "<CMD>lua require('fff').find_files()<CR>";
            desc = "fff find_files";
          }
        ];
          # matrix_pixel_threshold = 0.5;
          never_draw_over_target = true;
          time_interval = 10;
          trailing_stiffness = 0.6;
            rev = "d436d8f11f156de619baba72cd1fbc4216586cd6";
          light = "function() ColorMyPencils('gruvbox-material', 'light', false) end";
          dark = "function() ColorMyPencils('gruvbox-material', 'dark', false) end";
            rev = "5db97e2d132ebdf32c7e5edb5b0c68be9ae43038";
          vim.g.miniSnip_dirs = { "~/nixos-config/modules/common/editor/nvim/snippets" }
          icons = enabled {
            show_source.enabled = true;
            rev = "2575109749b4bf3a0bf979a17947b3c1e8c5137e";
          {
            mode = "n";
            key = "<leader>tq";
            action = "<cmd>Trouble qflist toggle<cr>";
            desc = "Open trouble quickfix list";
          }
          {
            mode = "n";
            key = "<leader>tdq";
            action = "<cmd>TodoQuickFix<cr>";
            desc = "Open trouble quickfix list";
          }
          }
        ];
      };
      "trouble.nvim" = {
        package = pkgs.vimPlugins.trouble-nvim;
        lazy = true;
        setupModule = "trouble";
        setupOpts = {
          auto_close = true;
        };
        keys = [
          {
            mode = "n";
            key = "<leader>tr";
            action = "<cmd>Trouble diagnostics toggle focus=true filter.buf=0<cr>";
            desc = "Open trouble for current file";
          }
          {
            mode = "n";
            key = "<leader>te";
            action = "<cmd>Trouble diagnostics toggle focus=true<cr>";
            desc = "Open trouble for workspace";
          modes.diagnostics.win.size = 0.3;
      "SchemaStore.nvim".package = pkgs.vimPlugins.SchemaStore-nvim;
      zenbones.lightness      = "bright";
      zenbones.italic_strings = false;
          ext    = ".md";
          path   = "~/vimwiki/healgorithms/";
          ext    = ".md";
          path   = "~/vimwiki/james/";
        svelte     = "svelte";
      vimwiki_global_ext        = 0;
{ pkgs, lib, fenix, fff-nvim, ... }:

{
    };
  };
}
      };
      mappings.telescope = "<leader>ftd";
  programs.nvf.settings.vim = {
    };
      };
    };
      };
    };
      };
    };
      };
    };
      };
    };
      };
    };
      };
    };
    notes.todo-comments = enabled {
      setupOpts = {
        signs             = false;
        highlight.before  = "";
        highlight.keyword = "wide";
        highlight.after   = "";
      # rest are handled in ./keymaps.nix
      mappings.findFiles           = null; # now using fff
      mappings.findProjects        = null;
      mappings.diagnostics         = null;
      mappings.gitBranches         = null;
      mappings.gitBufferCommits    = null;
      mappings.gitCommits          = null;
      mappings.gitStash            = null;
      mappings.helpTags            = null;
      mappings.lspDefinitions      = null;
      mappings.lspDocumentSymbols  = null;
      mappings.lspImplementations  = null;
      mappings.lspReferences       = null;
      mappings.lspTypeDefinitions  = null;
      mappings.lspWorkspaceSymbols = null;
      mappings.open                = null;
      mappings.liveGrep            = "<leader>fg";
      mappings.buffers             = "<leader>fb";
      mappings.treesitter          = "<leader>ft";
      mappings.resume              = "<leader>fc";
      mappings.gitStatus           = null;
    telescope = enabled {
      setupOpts.defaults = {
        prompt_prefix         = " ";
        selection_caret       = " ";
        entry_prefix          = " ";
        dynamic_preview_title = true;
        color_devicons        = false;
        path_display          = [ "truncate" ];
        sorting_strategy      = "ascending";
        layout_config.horizontal.prompt_position = "top";
        layout_config.horizontal.preview_width   = 0.6;
        vimgrep_arguments = [ "rg" "--color=never" "--no-heading" "--with-filename" "--line-number" "--column" "--smart-case" "--hidden" ];
    visuals.indent-blankline  = enabled;
    visuals.nvim-web-devicons = enabled;
    visuals.fidget-nvim = enabled {
      setupOpts = {
        progress.display.done_ttl        = 10;
        notification.override_vim_notify = true;
        notification.window.winblend     = 0;
        notification.window.zindex       = 1000;
        notification.window.max_width    = 60;
    utility.ccc = enabled;
    utility.diffview-nvim = enabled; # for neogit
    utility.undotree = enabled;
    utility.nvim-biscuits = enabled {
      setupOpts = {
        cursor_line_only = true;
        prefix_string    = " ";
        toggle_keybind   = "<leader>bi";
        show_on_start    = false;
    navigation.harpoon = disabled {
      mappings.file1 = "<leader>h";
      mappings.file2 = "<leader>j";
      mappings.file3 = "<leader>k";
      mappings.file4 = "<leader>l";
      setupOpts.defaults = {
        save_on_toggle   = true;
        save_on_ui_close = true;
        commit_editor.staged_diff_split_kind = "vsplit";
        commit_select_view.kind              = "vsplit";
    git.neogit = enabled {
      mappings.open = "<leader>g";
      setupOpts = {
        integrations.telescope = true;
        integrations.diffview  = true;
    mini.ai = enabled;
    mini.surround = enabled;
    mini.bufremove = enabled;
    mini.diff = enabled {
      setupOpts = {
        view.style = "number";
        mappings.apply      = "";
        mappings.reset      = "";
        mappings.textobject = "";
        mappings.goto_first = "";
        mappings.goto_prev  = "";
        mappings.goto_next  = "";
        mappings.goto_last  = "";
    autopairs.nvim-autopairs = enabled;
    in
    enabled {
      theme        = "gruvbox";
      globalStatus = false;
      componentSeparator.left  = "";
      componentSeparator.right = "";
      sectionSeparator.left    = "";
      sectionSeparator.right   = "";
      setupOpts.options.disabled_filetypes = [ "no-neck-pain" "dapui_watches" "dapui_scopes" "dapui_breakpoints" "dapui_stacks" "dap-repl" "dapui_console" ];
      activeSection   = sections;
      inactiveSection = sections;
    autocomplete.blink-cmp = enabled {
      setupOpts = {
        completion = {
        };
      };
    };
        a = [ ''{ "mode" }'' ];
        z = [ ''{ "location" }'' ];
        x = [ ];
        y = [ ''{ "encoding" }'' ''{ "fileformat" }'' ''{ "filetype" }'' ];
        b = [ ''{ "branch" } '' ''{ "diagnostics", symbols = { error = "", warn = "", info = "", hint = "" } }'' ];
        c = [ ''{ "filename", show_filename_only = false, path = 1 }'' ''{ "diff" }'' ];
    statusline.lualine =
    let
      sections = {
        signature.enabled = true;
        sources.providers.buffer.opts = mkLuaInline ''
          {
            get_bufnrs = function()
              return vim.tbl_filter(function(bufnr)
                return vim.bo[bufnr].buftype == ""
              end, vim.api.nvim_list_bufs())
            end,
          }
        '';
        cmdline.enabled   = false;
              {
                { "kind" },
                { "label", gap = 1 }
              }
            '';
          menu.winhighlight = "FloatBorder:None,Search:None";
          menu.draw.columns = mkLuaInline ''
          list.selection.preselect = false;
          documentation.window.winhighlight = "FloatBorder:None,Search:None";
        keymap.preset = "enter";
      mappings.next           = null;
      mappings.previous       = null;
      mappings.scrollDocsDown = "<C-d>";
      mappings.scrollDocsUp   = "<C-u>";
    assistant.supermaven-nvim = enabled {
      setupOpts.keymaps.accept_word       = "<RIGHT>";
      setupOpts.keymaps.accept_suggestion = "<TAB>";
{ pkgs, lib, ... }:
let
in
  inherit (lib) enabled disabled mkLuaInline;

DisableItalic()
DisableUndercurl()
-- DisableBold()
ColorMyPencils(current_theme, bg, false)
-- theme configuration from nix globals
local current_theme = vim.g.theme_name
local bg = vim.g.theme_variant

{
	"name": "james-snippets",
	"contributes": {
		"snippets": [
			{
				"language": [
					"all"
				],
				"path": "./snippets/all.json"
			},
			{
				"language": [
					"javascript",
                    "typescript"
				],
				"path": "./snippets/javascript.json"
			},
			{
				"language": [
					"svelte"
				],
				"path": "./snippets/svelte.json"
            }
		]
	}
}

{
   "tag": {
        "prefix": "tag",
        "body": [
            "<${1}>",
            "   $0",
            "</${1}>"
        ],
        "description": "HTML tag"
    }	
}

{
    "clog": {
        "prefix": "clog",
        "scope": "javascript,typescript",
        "body": [
            "console.log('$1');",
            "$2"
        ],
        "description": "Log output to console"
    }
}

{
    "script": {
        "prefix": "script",
        "body": [
            "<script lang=\"ts\">",
            "   $1",
            "</script>"
        ],
        "description": "opening script tags"
    },
    "sveltebp": {
        "prefix": "sveltebp",
        "body": [
            "<script lang=\"ts\">",
            "   $1",
            "</script>",
            "",
            "<div>",
            "     ",
            "</div>"
        ],
        "description": "script + divs"
    }
        
}

{ pkgs, config, lib, ... }:
	inherit (lib) disabled;
in
let
{
    extraPlugins = {
        };
      };
        };
      };
    };
  };
      # for zenbones
      "gruvbox-material.nvim" = {
        package = pkgs.vimPlugins.gruvbox-material-nvim;
        setup = "require('gruvbox-material').setup({contrast='hard'})";
      };
      "vimplugin-lush.nvim".package = pkgs.vimPlugins.lush-nvim;
      "vimplugin-zenbones.nvim".package = pkgs.vimPlugins.zenbones-nvim;
      "vimplugin-rasmus.nvim".package = pkgs.vimUtils.buildVimPlugin {
        name = "rasmus.nvim";
        src  = pkgs.fetchFromGitHub {
          owner  = "kvrohit";
          repo   = "rasmus.nvim";
          rev    = "49f7ee7bf3eb00db52c77f84b15bc69f318bafc1";
          sha256 = "sha256-MWc6zzMGZ6OceZGbx2qmuHe9FvIUXK1rtb+yIsfRokY=";
      "vimplugin-rusticated".package = pkgs.vimUtils.buildVimPlugin {
        name = "rusticated";
        src  = pkgs.fetchFromGitHub {
          owner  = "haystackandroid";
          repo   = "rusticated";
          rev    = "8052162f2c602725b4c0faf1d003404d5b9140c2";
          sha256 = "sha256-PF5rUyEMi05HsimfrfqpXNY6RAEBHctpBoJh733jogE=";
}
  programs.nvf.settings.vim = {
      style = config.theme.variant;
    };
    theme = disabled {
      name  = "gruvbox";

let
in
  inherit (lib) enabled disabled;
{
  programs.vim = enabled;
    };
  };
}
    settings.vim = {
      enableLuaLoader = true;
        (builtins.path { path = ./nvim/set_colorscheme.lua; })
      ];
      clipboard = enabled {
        registers = "unnamedplus";
        providers.wl-copy.enable = lib.mkIf pkgs.stdenv.isLinux true;
      };
      globals = {
        mapleader = " ";
        editorconfig = true;
        loaded_netrw       = 1;
        loaded_netrwPlugin = 1;
        # theme configuration for lua
        theme_name    = config.theme.nvim;
        theme_variant = config.theme.variant;
        is_dark       = config.theme.is_dark;
      };
      options = {
        # line numbers
        number         = true;
        relativenumber = true;
        # search
        ignorecase = true;
        smartcase  = true;
        # indentation
        tabstop     = 4;
        shiftwidth  = 4;
        softtabstop = 4;
        smartindent = true;
        # split handling
        splitbelow = true;
        splitright = true;
        # ui
        wrap          = false;
        pumheight     = 8;
        termguicolors = true;
        cursorline    = true;
        showmode      = false;
        showtabline   = 0;
        guicursor     = "";
        fillchars     = "eob:~,fold: ,foldopen:,foldsep: ,foldclose:,vert:┃,lastline:┃";
        winborder     = "single";
        # backups etc.
        undofile    = true;
        swapfile    = false;
        backup      = false;
        writebackup = false;
        # scrolling
        scrolloff     = 8;
        sidescrolloff = 10;
        smoothscroll  = true;
        # misc
        updatetime  = 50;
        mouse       = "";
        completeopt = "menuone,noselect";
        foldenable  = false;
      };
      additionalRuntimePaths = [ ./nvim/after ];
      extraLuaFiles          = [
  # lets see how helix goes
  programs.nvf = disabled {
  imports = [ ./nvim ];
{ pkgs, lib, config, ... }:

              inherit (inputs) fenix nvf bacon-ls fff-nvim;

              inherit (inputs) fenix bacon-ls;

          james = {
            imports = [ inputs.nvf.homeManagerModules.default ];
          };

          james = {};

          james = {
            imports = [ inputs.nvf.homeManagerModules.default ];
          };

          james = {};

          james = {
            imports = [ inputs.nvf.homeManagerModules.default ];
          };

          james = {};

    nvf.url = "github:notashelf/nvf";
    nvf.inputs.nixpkgs.follows = "nixpkgs";

    fff-nvim.url = "github:dmtrKovalenko/fff.nvim";
    fff-nvim.inputs.nixpkgs.follows = "nixpkgs";

  outputs = inputs @ { nixpkgs, nixos-wsl, nix-darwin, home-manager, fenix, nvf, bacon-ls, fff-nvim, disko, agenix, github2forgejo, ... }: let

  outputs = inputs @ { nixpkgs, nixos-wsl, nix-darwin, home-manager, fenix, bacon-ls, disko, agenix, github2forgejo, ... }: let

        "type": "github"
      }
    },
    "crane": {
      "locked": {
        "lastModified": 1753316655,
        "narHash": "sha256-tzWa2kmTEN69OEMhxFy+J2oWSvZP5QhEgXp3TROOzl0=",
        "owner": "ipetkov",
        "repo": "crane",
        "rev": "f35a3372d070c9e9ccb63ba7ce347f0634ddf3d2",
        "type": "github"
      },
      "original": {
        "owner": "ipetkov",
        "repo": "crane",

        "type": "github"
      }
    },
    "fff-nvim": {
      "inputs": {
        "crane": "crane",
        "flake-utils": "flake-utils_2",
        "nixpkgs": [
          "nixpkgs"
        ],
        "rust-overlay": "rust-overlay"
      },
      "locked": {
        "lastModified": 1756915243,
        "narHash": "sha256-X/gOdElvxGxEmWlKKEwiRcyJdrh0DfV3BhY81UyQE7o=",
        "owner": "dmtrKovalenko",
        "repo": "fff.nvim",
        "rev": "56ea1404f177c4c4e531b879d8e35463cec192ec",
        "type": "github"
      },
      "original": {
        "owner": "dmtrKovalenko",
        "repo": "fff.nvim",

    "flake-compat_2": {
      "flake": false,
      "locked": {
        "lastModified": 1751685974,
        "narHash": "sha256-NKw96t+BgHIYzHUjkTK95FqYRVKB8DHpVhefWSz/kTw=",
        "ref": "refs/heads/main",
        "rev": "549f2762aebeff29a2e5ece7a7dc0f955281a1d1",
        "revCount": 92,
        "type": "git",
        "url": "https://git.lix.systems/lix-project/flake-compat.git"
      },
      "original": {
        "type": "git",
        "url": "https://git.lix.systems/lix-project/flake-compat.git"
      }
    },
    "flake-parts": {
      "inputs": {
        "nixpkgs-lib": [
          "nvf",
          "nixpkgs"
        ]
      },
      "locked": {
        "lastModified": 1756770412,
        "narHash": "sha256-+uWLQZccFHwqpGqr2Yt5VsW/PbeJVTn9Dk6SHWhNRPw=",
        "owner": "hercules-ci",
        "repo": "flake-parts",
        "rev": "4524271976b625a4a605beefd893f270620fd751",
        "type": "github"
      },
      "original": {
        "owner": "hercules-ci",
        "repo": "flake-parts",
        "type": "github"
      }
    },

    "flake-utils_2": {
      "inputs": {
        "systems": "systems_3"
      },
      "locked": {
        "lastModified": 1731533236,
        "narHash": "sha256-l0KFg5HjrsfsO/JpG+r7fRrqm12kzFHyUHqHCVpMMbI=",
        "owner": "numtide",
        "repo": "flake-utils",
        "rev": "11707dc2f618dd54ca8739b309ec4fc024de578b",
        "type": "github"
      },
      "original": {
        "owner": "numtide",
        "repo": "flake-utils",
        "type": "github"
      }
    },

        "systems": "systems_4"

        "systems": "systems_3"

    "mnw": {
      "locked": {
        "lastModified": 1756659871,
        "narHash": "sha256-v6Rh4aQ6RKjM2N02kK9Usn0Ix7+OY66vNpeklc1MnGE=",
        "owner": "Gerg-L",
        "repo": "mnw",
        "rev": "ed6cc3e48557ba18266e598a5ebb6602499ada16",
        "type": "github"
      },
      "original": {
        "owner": "Gerg-L",
        "repo": "mnw",
        "type": "github"
      }
    },

    "nvf": {
      "inputs": {
        "flake-compat": "flake-compat_2",
        "flake-parts": "flake-parts",
        "mnw": "mnw",
        "nixpkgs": [
          "nixpkgs"
        ],
        "systems": "systems_5"
      },
      "locked": {
        "lastModified": 1757095994,
        "narHash": "sha256-AXwM6/7CuQ39iwBqmc6ZNkVcCdFiK4MFRIGQgU6Mkyk=",
        "owner": "notashelf",
        "repo": "nvf",
        "rev": "fb31022b366ad21951f0352f0cc282cc6a8e9e6f",
        "type": "github"
      },
      "original": {
        "owner": "notashelf",
        "repo": "nvf",
        "type": "github"
      }
    },

        "fff-nvim": "fff-nvim",

        "nixpkgs": "nixpkgs_2",
        "nvf": "nvf"

        "nixpkgs": "nixpkgs_2"

        "type": "github"
      }
    },
    "rust-overlay": {
      "inputs": {
        "nixpkgs": [
          "fff-nvim",
          "nixpkgs"
        ]
      },
      "locked": {
        "lastModified": 1756866691,
        "narHash": "sha256-YWJsM0HfdFLcaoP5OeyzjX6MjGnJ0Acm+bg1QN8MKjo=",
        "owner": "oxalica",
        "repo": "rust-overlay",
        "rev": "fb6dab6f320291a8edd31c1d67f078c6f7384a02",
        "type": "github"
      },
      "original": {
        "owner": "oxalica",
        "repo": "rust-overlay",

    },
    "systems_4": {
      "locked": {
        "lastModified": 1681028828,
        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
        "owner": "nix-systems",
        "repo": "default",
        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
        "type": "github"
      },
      "original": {
        "owner": "nix-systems",
        "repo": "default",
        "type": "github"
      }
    },
    "systems_5": {
      "locked": {
        "lastModified": 1681028828,
        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
        "owner": "nix-systems",
        "repo": "default",
        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
        "type": "github"
      },
      "original": {
        "owner": "nix-systems",
        "repo": "default",
        "type": "github"
      }