return {
    {
        "folke/snacks.nvim",
        priority = 1000,
        lazy = false,
        ---@type snacks.Config
        opts = {
            animate = {
                enabled = false,
                duration = { step =  1, total = 1 },
                easing = "linear",
            },
            bigfile = { enabled = true },
            dashboard = { enabled = false },
            explorer = { enabled = false },
            image = {
                enabled = true,
                inline = false,
                scale = 3, -- nil | 1 (default) | 2  | 3 | ...
                doc = {
                    inline = true,
                    enabled = true,
                    max_width = nil,
                    max_height = nil,
                    conceal = true,
                },
                math = {
                    enabled = true,
                }
            },
            terminal = { 
                bo = {
                    filetype = "snacks_terminal",
                },
                win = { style = "terminal" },
                wo = {},
                keys = {
                    q = "hide",
                    gf = function(self)
                        local f = vim.fn.findfile(vim.fn.expand("<cfile>"), "**")
                        if f == "" then
                            Snacks.notify.warn("No file under cursor")
                        else
                            self:hide()
                            vim.schedule(function()
                                vim.cmd("e " .. f)
                            end)
                        end
                    end,
                    term_normal = {
                        "<esc><esc>",
                        function(self)
                            self.esc_timer = self.esc_timer or (vim.uv or vim.loop).new_timer()
                            if self.esc_timer:is_active() then
                                self.esc_timer:stop()
                                vim.cmd("stopinsert")
                            else
                                self.esc_timer:start(250, 0, function() end)
                                return "<esc>"
                            end
                        end,
                        mode = "t",
                        expr = true,
                        desc = "Double escape to normal mode",
                    },
                },
            },
            indent = { enabled = false },
            notifier = {
                enabled = true,
                timeout = 1000,
            },
            picker = {
                enabled = true,
                layout = { preset = "ivy", layout = { position = "bottom" } },
                frecency = true,
                history_bonus = true,
                projects = {
                    dev = { "~/Projects", },
                },
                win = {
                    input = {
                        keys = {
                            ['<c-e>'] = { 'layout_right', mode = { 'i', 'n' } },
                        },
                    },
                },
                sources = {
                    files = {
                        -- add a custom action
                        actions = {
                            create_if_missing = function(picker, item)
                                -- When typing in the input, item may be nil.
                                -- We'll use the input text as the intended file path.
                                local input = picker.input and picker.input:get() or ""
                                if input == "" then return end

                                -- Make it relative to picker cwd if it’s not absolute
                                local cwd = picker.opts.cwd or vim.loop.cwd()
                                local path = input
                                if not path:match("^/") and not path:match("^%a:[/\\]") then
                                    path = cwd .. "/" .. path
                                end

                                -- Normalize path (optional)
                                path = vim.fn.fnamemodify(path, ":p")

                                -- If file exists, just open it
                                if vim.loop.fs_stat(path) then
                                    picker:close()
                                    vim.cmd.edit(path)
                                    return
                                end

                                -- Ensure parent dirs exist (optional but nice)
                                vim.fn.mkdir(vim.fn.fnamemodify(path, ":h"), "p")

                                -- Open a new buffer at that path (creates buffer even if file missing)
                                picker:close()
                                vim.cmd.edit(path)
                                -- At this point buffer is new + unnamed-on-disk until you :w
                            end,
                        },

                        -- bind the action to a key in the picker UI
                        win = {
                            input = {
                                keys = {
                                    ["<M-n>"] = { "create_if_missing", mode = { "i", "n" }, desc = "Create file from input" },
                                },
                            },
                            list = {
                                keys = {
                                    ["<M-n>"] = { "create_if_missing", mode = { "n" }, desc = "Create file from input" },
                                },
                            },
                        },
                    },
                },
            },
            scope = { enabled = false },
            scratch = {
                ft = "markdown",
            },
            statuscolumn = { enabled = true },
            styles = {
                notification = {
                    -- wo = { wrap = true } -- Wrap notifications
                }
            }
        },
        keys = {
            -- Org Search
            { "<leader>o/", function() Snacks.picker.grep({dirs = { os.getenv("HOME") .. "/Documents/notes" }}) end, desc = "Search Org Files" },
            -- { "<leader>o/", function() Snacks.picker.files({ cwd = os.getenv("HOME") .. "/Documents/notes" }) end, desc = "Find Document" },
            -- Top Pickers & Explorer
            { "<leader><Space>", function() Snacks.picker.smart() end, desc = "Smart Find Files" },
            { "<leader>j", function() Snacks.picker.files({args = { "--no-require-git" }}) end, desc = "Find Files" },
            { "<leader>,", function() Snacks.picker.buffers() end, desc = "Buffers" },
            { "<leader>/", function() Snacks.picker.grep() end, desc = "Grep" },
            { "<leader>:", function() Snacks.picker.command_history() end, desc = "Command History" },
            { "<leader>n", function() Snacks.picker.notifications() end, desc = "Notification History" },
            { "<leader>i", function() Snacks.picker.lsp_symbols() end, desc = "Symbols" },
            { "<leader>I", function() Snacks.picker.lsp_workspace_symbols() end, desc = "LSP Workspace Symbols" },
            -- { "<leader>e", function() Snacks.explorer() end, desc = "File Explorer" },
            -- find
            { "<leader>fb", function() Snacks.picker.buffers() end, desc = "Buffers" },
            { "<leader>fc", function() Snacks.picker.files({ cwd = vim.fn.stdpath("config") }) end, desc = "Find Config File" },
            { "<leader>ff", function() Snacks.picker.files() end, desc = "Find Files" },
            { "<leader>fg", function() Snacks.picker.git_files() end, desc = "Find Git Files" },
            { "<leader>fp", function() Snacks.picker.projects() end, desc = "Projects" },
            { "<leader>fr", function() Snacks.picker.recent() end, desc = "Recent" },
            -- git
            { "<leader>gb", function() Snacks.picker.git_branches() end, desc = "Git Branches" },
            { "<leader>gl", function() Snacks.picker.git_log() end, desc = "Git Log" },
            { "<leader>gL", function() Snacks.picker.git_log_line() end, desc = "Git Log Line" },
            { "<leader>gs", function() Snacks.picker.git_status() end, desc = "Git Status" },
            { "<leader>gS", function() Snacks.picker.git_stash() end, desc = "Git Stash" },
            { "<leader>gd", function() Snacks.picker.git_diff() end, desc = "Git Diff (Hunks)" },
            { "<leader>gf", function() Snacks.picker.git_log_file() end, desc = "Git Log File" },
            -- Grep
            { "<leader>sb", function() Snacks.picker.lines() end, desc = "Buffer Lines" },
            { "<leader>sB", function() Snacks.picker.grep_buffers() end, desc = "Grep Open Buffers" },
            { "<leader>sg", function() Snacks.picker.grep() end, desc = "Grep" },
            { "<leader>sw", function() Snacks.picker.grep_word() end, desc = "Visual selection or word", mode = { "n", "x" } },
            -- search
            { '<leader>s"', function() Snacks.picker.registers() end, desc = "Registers" },
            { '<leader>s/', function() Snacks.picker.search_history() end, desc = "Search History" },
            { "<leader>sa", function() Snacks.picker.autocmds() end, desc = "Autocmds" },
            { "<leader>sb", function() Snacks.picker.lines() end, desc = "Buffer Lines" },
            { "<leader>sc", function() Snacks.picker.command_history() end, desc = "Command History" },
            { "<leader>sC", function() Snacks.picker.commands() end, desc = "Commands" },
            { "<leader>sd", function() Snacks.picker.diagnostics() end, desc = "Diagnostics" },
            { "<leader>sD", function() Snacks.picker.diagnostics_buffer() end, desc = "Buffer Diagnostics" },
            { "<leader>sh", function() Snacks.picker.help() end, desc = "Help Pages" },
            { "<leader>sH", function() Snacks.picker.highlights() end, desc = "Highlights" },
            { "<leader>si", function() Snacks.picker.icons() end, desc = "Icons" },
            { "<leader>sj", function() Snacks.picker.jumps() end, desc = "Jumps" },
            { "<leader>sk", function() Snacks.picker.keymaps() end, desc = "Keymaps" },
            { "<leader>sl", function() Snacks.picker.loclist() end, desc = "Location List" },
            { "<leader>sm", function() Snacks.picker.marks() end, desc = "Marks" },
            { "<leader>sM", function() Snacks.picker.man() end, desc = "Man Pages" },
            { "<leader>sp", function() Snacks.picker.lazy() end, desc = "Search for Plugin Spec" },
            { "<leader>sq", function() Snacks.picker.qflist() end, desc = "Quickfix List" },
            { "<leader>sR", function() Snacks.picker.resume() end, desc = "Resume" },
            { "<leader>su", function() Snacks.picker.undo() end, desc = "Undo History" },
            { "<leader>sz", function() Snacks.picker.zoxide() end, desc = "Zoxide" },
            { "<leader>uC", function() Snacks.picker.colorschemes() end, desc = "Colorschemes" },
            -- LSP
            { "gd", function() Snacks.picker.lsp_definitions() end, desc = "Goto Definition" },
            { "gD", function() Snacks.picker.lsp_declarations() end, desc = "Goto Declaration" },
            { "grr", function() Snacks.picker.lsp_references() end, nowait = true, desc = "References" },
            { "gri", function() Snacks.picker.lsp_implementations() end, desc = "Goto Implementation" },
            { "gy", function() Snacks.picker.lsp_type_definitions() end, desc = "Goto T[y]pe Definition" },
            { "<leader>ss", function() Snacks.picker.lsp_symbols() end, desc = "LSP Symbols" },
            { "<leader>sS", function() Snacks.picker.lsp_workspace_symbols() end, desc = "LSP Workspace Symbols" },
            -- Other
            { "<leader>Z",  function() Snacks.zen() end, desc = "Toggle Zen Mode" },
            { "<leader>z",  function() Snacks.zen.zoom() end, desc = "Toggle Zoom" },
            { "<leader>.",  function() Snacks.scratch() end, desc = "Toggle Scratch Buffer" },
            { "<leader>S",  function() Snacks.scratch.select() end, desc = "Select Scratch Buffer" },
            -- { "<leader>n",  function() Snacks.notifier.show_history() end, desc = "Notification History" },
            { "<leader>bd", function() Snacks.bufdelete() end, desc = "Delete Buffer" },
            { "<leader>bR", function() Snacks.rename.rename_file() end, desc = "Rename File" },
            { "<leader>gB", function() Snacks.gitbrowse() end, desc = "Git Browse", mode = { "n", "v" } },
            { "<leader>gg", function() Snacks.lazygit() end, desc = "Lazygit" },
            { "<leader>un", function() Snacks.notifier.hide() end, desc = "Dismiss All Notifications" },
            { "<c-_>",     function() Snacks.terminal.toggle() end, desc = "Toggle Terminal", mode = { "n", "t" } },
            -- { "<Esc>",     "<C-\\><C-n>", desc = "Exit Terminal Mode", mode = { "t" } },
            { "]]",         function() Snacks.words.jump(vim.v.count1) end, desc = "Next Reference", mode = { "n", "t" } },
            { "[[",         function() Snacks.words.jump(-vim.v.count1) end, desc = "Prev Reference", mode = { "n", "t" } },
            {
                "<leader>xN",
                desc = "Neovim News",
                function()
                    Snacks.win({
                        file = vim.api.nvim_get_runtime_file("doc/news.txt", false)[1],
                        width = 0.6,
                        height = 0.6,
                        wo = {
                            spell = false,
                            wrap = false,
                            signcolumn = "yes",
                            statuscolumn = " ",
                            conceallevel = 3,
                        },
                    })
                end,
            }
        },
        init = function()
            vim.api.nvim_create_autocmd("User", {
                pattern = "VeryLazy",
                callback = function()
                    -- Setup some globals for debugging (lazy-loaded)
                    _G.dd = function(...)
                        Snacks.debug.inspect(...)
                    end
                    _G.bt = function()
                        Snacks.debug.backtrace()
                    end
                    vim.print = _G.dd -- Override print to use snacks for `:=` command

                    -- Create some toggle mappings
                    Snacks.toggle.option("spell", { name = "Spelling" }):map("<leader>us")
                    Snacks.toggle.option("wrap", { name = "Wrap" }):map("<leader>uw")
                    Snacks.toggle.option("relativenumber", { name = "Relative Number" }):map("<leader>uL")
                    Snacks.toggle.diagnostics():map("<leader>ud")
                    Snacks.toggle.line_number():map("<leader>ul")
                    Snacks.toggle.option("conceallevel", { off = 0, on = vim.o.conceallevel > 0 and vim.o.conceallevel or 2 }):map("<leader>uc")
                    Snacks.toggle.treesitter():map("<leader>uT")
                    Snacks.toggle.option("background", { off = "light", on = "dark", name = "Dark Background" }):map("<leader>ub")
                    Snacks.toggle.inlay_hints():map("<leader>uh")
                    Snacks.toggle.indent():map("<leader>ug")
                    Snacks.toggle.dim():map("<leader>uD")
                end,
            })
        end,
    },
    {
        "folke/todo-comments.nvim",
        lazy = true,
        keys = {
            { "<leader>st", function() Snacks.picker.todo_comments() end, desc = "Todo" },
            { "<leader>sT", function() Snacks.picker.todo_comments({ keywords = { "TODO", "FIX", "FIXME", "NOTE" } }) end, desc = "Todo/Fix/Fixme/Note" },
        },
        opts = {},
    },
    {
        'L3MON4D3/LuaSnip',
        dependencies = {
            'rafamadriz/friendly-snippets',
        },
        version = "v2.*",
        build = "make install_jsregexp",
        config = function()
            require('luasnip.loaders.from_vscode').lazy_load()
            require('luasnip.loaders.from_vscode').lazy_load({ paths = "./json_snippets" })
            local luasnip = require("luasnip")
            luasnip.add_snippets("zig", require("snippets.zig"))
        end,
    },
    {
        'saghen/blink.cmp',
        lazy = false, -- lazy loading handled internally
        -- optional: provides snippets for the snippet source
        dependencies = {
            'L3MON4D3/LuaSnip',
            'moyiz/blink-emoji.nvim',
            'MeanderingProgrammer/render-markdown.nvim',
            'fang2hou/blink-copilot',
            --'giuxtaposition/blink-cmp-copilot',
        },
        version = '1.*',
        config = function()
            -- NOTE: Specify the trigger character(s) used for luasnip
            -- local trigger_text = ";"
            require('blink.cmp').setup({
                enabled = function()
                    local filetype = vim.bo[0].filetype
                    if filetype == "TelescopePrompt" or filetype == "minifiles" or filetype == "snacks_picker_input" then
                        return false
                    end
                    return true
                end,
                snippets = { preset = 'luasnip' },
                completion = {
                    --   keyword = {
                    --     -- 'prefix' will fuzzy match on the text before the cursor
                    --     -- 'full' will fuzzy match on the text before *and* after the cursor
                    --     -- example: 'foo_|_bar' will match 'foo_' for 'prefix' and 'foo__bar' for 'full'
                    --     range = "full",
                    --   },
                    menu = {
                        draw = {
                            treesitter = { 'lsp' }
                        }
                        --     border = "single",
                    },
                    list = {
                        selection = {
                            preselect = false,
                            auto_insert = false,
                        }
                    },
                    documentation = {
                        auto_show = true,
                        auto_show_delay_ms = 500,
                        -- window = {
                        --     border = "single",
                        -- },
                    },
                    ghost_text = { enabled = false },
                },
                cmdline = {
                    enabled = true,
                },
                signature = { enabled = true },
                sources = {
                    per_filetype = {
                        org = {'orgmode'}
                    },
                    default = { 'orgmode', 'lsp', 'copilot', 'snippets', 'path', 'omni', 'buffer', 'codecompanion', 'markdown' },
                    providers = {
                        codecompanion = {
                            name = "CodeCompanion" ,
                            module = "codecompanion.providers.completion.blink",
                            enabled = true,
                        },
                        orgmode = {
                            name = 'Orgmode',
                            module = 'orgmode.org.autocompletion.blink',
                            fallbacks = { 'buffer' },
                        },
                        copilot = {
                            name = 'copilot',
                            module = 'blink-copilot',
                            score_offset = 100,
                            async = true,
                        },
                        markdown = {
                            name = 'RenderMarkdown',
                            module = 'render-markdown.integ.blink',
                            score_offset = 80,
                        },
                        lsp = {
                            name = 'lsp', -- IMPORTANT: use the same name as you would for nvim-cmp
                            enabled = true,
                            module = 'blink.cmp.sources.lsp',
                            -- fallbacks = { 'snippets', 'buffer', 'path' },
                            score_offset = 100,
                        },
                        path = {
                            name = 'path', -- IMPORTANT: use the same name as you would for nvim-cmp
                            module = 'blink.cmp.sources.path',
                            score_offset = 50,
                            fallbacks = { 'snippets', 'buffer' },
                            opts = {
                                trailing_slash = false,
                                label_trailing_slash = true,
                                get_cwd = function(context)
                                    return vim.fn.expand(("#%d:p:h"):format(context.bufnr))
                                end,
                                show_hidden_files_by_default = true,
                            },
                        },
                        buffer = {
                            name = "Buffer",
                            enabled = true,
                            max_items = 3,
                            module = "blink.cmp.sources.buffer",
                            min_keyword_length = 4,
                            score_offset = 15, -- the higher the number, the higher the priority
                        },
                        snippets = {
                            name = "snippets",
                            enabled = true,
                            max_items = 15,
                            min_keyword_length = 2,
                            module = "blink.cmp.sources.snippets",
                            score_offset = 90, -- the higher the number, the higher the priority
                        },
                        emoji = {
                            module = "blink-emoji",
                            name = "Emoji",
                            score_offset = 0, -- the higher the number, the higher the priority
                            opts = { insert = true }, -- Insert emoji (default) or complete its name
                        },
                    },
                },
                appearance = {
                    -- Blink does not expose its default kind icons so you must copy them all (or set your custom ones) and add Copilot
                    kind_icons = {
                        Copilot = "",
                        Text = '󰉿',
                        Method = '󰊕',
                        Function = '󰊕',
                        Constructor = '󰒓',

                        Field = '󰜢',
                        Variable = '󰆦',
                        Property = '󰖷',

                        Class = '󱡠',
                        Interface = '󱡠',
                        Struct = '󱡠',
                        Module = '󰅩',

                        Unit = '󰪚',
                        Value = '󰦨',
                        Enum = '󰦨',
                        EnumMember = '󰦨',

                        Keyword = '󰻾',
                        Constant = '󰏿',

                        Snippet = '󱄽',
                        Color = '󰏘',
                        File = '󰈔',
                        Reference = '󰬲',
                        Folder = '󰉋',
                        Event = '󱐋',
                        Operator = '󰪚',
                        TypeParameter = '󰬛',
                    },
                },
            })
        end
    },
    {
        'stevearc/conform.nvim',
        event = { 'BufWritePre' },
        cmd = { 'ConformInfo' },
        keys = {
            {
                '<leader>bf',
                function()
                    require('conform').format { async = true, lsp_format = 'fallback' }
                end,
                mode = { 'n', 'v' },
                desc = 'Format buffer',
            },
        },
        opts = {
            notify_on_error = false,
            formatters = {
                shfmt = {
                    prepend_args = { "-i", "2", "-ci" },
                },
                dprint = {
                    condition = function(ctx)
                        return vim.fs.find({ "dprint.json" }, { path = ctx.filename, upward = true })[1]
                    end,
                },
            },
            formatters_by_ft = {
                c = { "clang_format" },
                cpp = { "clang_format" },
                lua = { 'stylua' },
                go = { "goimports", "gofmt" },
                rust = { "dprint", "rustfmt", lsp_format = "fallback" },
                python = { "isort", "black", stop_after_first = true },
                javascript = { "dprint", "prettier", stop_after_first = true   },
                markdown = { "dprint", "prettier", stop_after_first = true },
                javascriptreact = { "dprint", "prettier", stop_after_first = true },
                typescript = { "dprint", "prettier", stop_after_first = true },
                typescriptreact = { "dprint", "prettier", stop_after_first = true },
                svelte = { "dprint", "prettier", stop_after_first = true },
                html = { "dprint", "prettier", stop_after_first = true },
            },
        },
    },
    {
        'lewis6991/gitsigns.nvim',
        event = "VimEnter",
        keys = {
            { '<leader>uG', "Gitsigns toggle_signs", mode = { 'n' }, desc = 'Gitsigns toggle', },
        },
        opts = {
            auto_attach = true,
            signs_staged_enable = true,
            signcolumn = true,
            current_line_blame_opts = {
                delay = 50
            },
            on_attach = function(bufnr)
                local gitsigns = require('gitsigns')

                local function map(mode, l, r, opts)
                    opts = opts or {}
                    opts.buffer = bufnr
                    vim.keymap.set(mode, l, r, opts)
                end

                -- Actions
                -- visual mode
                map('v', '<leader>vs', function()
                    gitsigns.stage_hunk { vim.fn.line '.', vim.fn.line 'v' }
                end, { desc = 'stage git hunk' })

                map('v', '<leader>vr', function()
                    gitsigns.reset_hunk { vim.fn.line '.', vim.fn.line 'v' }
                end, { desc = 'reset git hunk' })

                -- normal mode

                map('n', '[v', function() gitsigns.nav_hunk 'prev' end, { desc = 'git previous hunk' })
                map('n', ']v', function() gitsigns.nav_hunk 'next' end, { desc = 'git next hunk' })
                map('n', '<leader>vs', gitsigns.stage_hunk, { desc = 'git stage hunk' })
                map('n', '<leader>vr', gitsigns.reset_hunk, { desc = 'git reset hunk' })
                map('n', '<leader>vS', gitsigns.stage_buffer, { desc = 'git stage buffer' })
                map('n', '<leader>vu', gitsigns.undo_stage_hunk, { desc = 'git undo stage hunk' })
                map('n', '<leader>vR', gitsigns.reset_buffer, { desc = 'git reset buffer' })
                map('n', '<leader>vP', gitsigns.preview_hunk, { desc = 'git preview hunk' })
                map('n', '<leader>vb', gitsigns.blame_line, { desc = 'git blame line' })
                map('n', '<leader>vP', gitsigns.diffthis, { desc = 'git diff against index' })
                map('n', '<leader>vD', function()
                    gitsigns.diffthis '@'
                end, { desc = 'git [D]iff against last commit' })
                -- Toggles
                map('n', '<leader>uvb', gitsigns.toggle_current_line_blame, { desc = '[T]oggle git show [b]lame line' })
                map('n', '<leader>uvd', gitsigns.toggle_deleted, { desc = '[T]oggle git show [D]eleted' })
            end,
        }
    },
    {
        "dlyongemallo/diffview.nvim",
        --"sindrets/diffview.nvim",
    },
    {
        "NicolasGB/jj.nvim",
        version = "*", -- Use latest stable release
        -- Or from the main branch (uncomment the branch line and comment the version line)
        -- branch = "main",
        keys = function()
            local cmd = require("jj.cmd")
            local annotate = require("jj.annotate")

            vim.keymap.set("n", "<leader>va", annotate.file, { desc = "JJ annotate file" })
            vim.keymap.set("n", "<leader>vA", annotate.line, { desc = "JJ annotate line" })
            vim.keymap.set("n", "<leader>vbc", cmd.bookmark_create, { desc = "JJ bookmark create" })
            vim.keymap.set("n", "<leader>vbd", cmd.bookmark_delete, { desc = "JJ bookmark delete" })
            vim.keymap.set("n", "<leader>vbm", cmd.bookmark_move, { desc = "JJ bookmark move" })
            vim.keymap.set("n", "<leader>vd", cmd.describe, { desc = "JJ describe" })
            vim.keymap.set("n", "<leader>vl", cmd.log, { desc = "JJ log" })
            vim.keymap.set("n", "<leader>ve", cmd.edit, { desc = "JJ edit" })
            vim.keymap.set("n", "<leader>vn", cmd.new, { desc = "JJ new" })
            vim.keymap.set("n", "<leader>vs", cmd.status, { desc = "JJ status" })
            vim.keymap.set("n", "<leader>vS", cmd.squash, { desc = "JJ squash" })
            vim.keymap.set("n", "<leader>vju", cmd.undo, { desc = "JJ undo" })
            vim.keymap.set("n", "<leader>vjr", cmd.redo, { desc = "JJ redo" })
            vim.keymap.set("n", "<leader>vr", cmd.rebase, { desc = "JJ rebase" })
            vim.keymap.set("n", "<leader>vf", cmd.fetch, { desc = "JJ fetch" })
            vim.keymap.set("n", "<leader>vx", cmd.abandon, { desc = "JJ abandon" })
            vim.keymap.set("n", "<leader>vp", cmd.push, { desc = "JJ push" })
            vim.keymap.set("n", "<leader>vpr", cmd.open_pr, { desc = "JJ open PR from bookmark in current revision or parent" })
            vim.keymap.set("n", "<leader>vpl", function()
                cmd.open_pr { list_bookmarks = true }
            end, { desc = "JJ open PR listing available bookmarks" })


            -- Diff commands
            local diff = require("jj.diff")
            vim.keymap.set("n", "<leader>vjd", function() diff.open_vdiff() end, { desc = "JJ diff current buffer" })
            vim.keymap.set("n", "<leader>vjD", function() diff.open_hsplit() end, { desc = "JJ hdiff current buffer" })

            -- Pickers
            local picker = require("jj.picker")
            vim.keymap.set("n", "<leader>vjs", function() picker.status() end, { desc = "JJ Picker status" })
            vim.keymap.set("n", "<leader>vjh", function() picker.file_history() end, { desc = "JJ Picker history" })

            -- Some functions like `log` can take parameters
            vim.keymap.set("n", "<leader>vL", function()
                cmd.log {
                    revisions = "all()", -- equivalent to jj log -r ::
                }
            end, { desc = "JJ log all" })


            -- This is an alias i use for moving bookmarks its so good
            vim.keymap.set("n", "<leader>vt", function()
                cmd.j "tug"
                cmd.log {}
            end, { desc = "JJ tug" })

        end, 
        config = function()
            require("jj").setup({
                diff = {
                    backend = "native",
                },
                cmd = {
                    describe = {
                        editor = {
                            type = "buffer",
                        }
                    }
                },
                describe = {
                    editor = {
                        type = "buffer",
                    }
                }
            })
        end,
    },
    {
        "julienvincent/hunk.nvim",
        cmd = { "DiffEditor" },
        config = function()
            require("hunk").setup()
        end,
    },
    {
        -- "PrayagS/jj-diffconflicts",
        -- branch = 'fix-for-jj-v0_37_0',
        "rafikdraoui/jj-diffconflicts"
    },
    {
        'Glhou/jjsigns.nvim',
        branch = 'fix/skip-extra-lines',
        config = function()
            require('jjsigns').setup({
                enabled = true,
                attach = {
                    auto = false,
                }
            })
        end,
    },
    { 'williamboman/mason.nvim', lazy = true, opts = {} },
    { 'williamboman/mason-lspconfig.nvim', lazy = true },
    { 'WhoIsSethDaniel/mason-tool-installer.nvim', lazy = true },
    {
        'neovim/nvim-lspconfig', 
        lazy = false,
        dependencies = {
            { 'SmiteshP/nvim-navic', lazy = true },
        },
        keys = function()
            vim.keymap.set("i", "<C-.>", function() 
                if not vim.lsp.inline_completion.get() then
                    return "<C-.>"
                end
            end, { expr = true, desc = "Accept the current inline completion" })
        end,
        config = function()

            vim.api.nvim_create_autocmd('LspAttach', {
                group = vim.api.nvim_create_augroup('kickstart-lsp-attach', { clear = true }),
                callback = function(event)
                    local function client_supports_method(client, method, bufnr)
                        return client:supports_method(method, bufnr)
                    end

                    local client = vim.lsp.get_client_by_id(event.data.client_id)
                    if client and client:supports_method(vim.lsp.protocol.Methods.textDocument_completion, event.buf) then
                        vim.lsp.completion.enable(true, client.id, event.buf, { autotrigger = true })
                    end
                end,
            })

            -- Diagnostic Config
            -- See :help vim.diagnostic.Opts
            vim.diagnostic.config({
                severity_sort = true,
                float = { border = 'rounded', source = 'if_many' },
                underline = { severity = vim.diagnostic.severity.ERROR },
                signs = vim.g.have_nerd_font and {
                    text = {
                        [vim.diagnostic.severity.ERROR] = '󰅚 ',
                        [vim.diagnostic.severity.WARN] = '󰀪 ',
                        [vim.diagnostic.severity.INFO] = '󰋽 ',
                        [vim.diagnostic.severity.HINT] = '󰌶 ',
                    },
                } or {},
                virtual_text = {
                    source = 'if_many',
                    spacing = 2,
                    format = function(diagnostic)
                        local diagnostic_message = {
                            [vim.diagnostic.severity.ERROR] = diagnostic.message,
                            [vim.diagnostic.severity.WARN] = diagnostic.message,
                            [vim.diagnostic.severity.INFO] = diagnostic.message,
                            [vim.diagnostic.severity.HINT] = diagnostic.message,
                        }
                        return diagnostic_message[diagnostic.severity]
                    end,
                },
            })


            local servers = {
                lua_ls = {
                    settings = {
                        Lua = {
                            runtime = {
                                version = 'LuaJIT',
                            },
                            workspace = {
                                library = vim.api.nvim_get_runtime_file("", true),
                                checkThirdParty = false,
                            },
                            completion = {
                                callSnippet = "Replace",
                            },
                            diagnostics = {
                                disable = { 'missing-fields' },
                                globals = { 'vim', 'require' }, 
                            },

                        },
                    }
                },
                gopls = {
                    settings = {
                        gopls = {
                            experimentalPostfixCompletions = true,
                            analyses = {
                                unusedparams = true,
                                shadow = true,
                            },
                            staticcheck = true,
                            hints = {
                                enabled = true,
                                rangeVariableTypes = true,
                                prameterNames = true,
                                functionTypeParameters = true,
                                constantValues = true,
                                compositeLiteralTypes = true,
                                compositeLiteralFields = true,
                                assignVariableTypes = true,
                            },
                        },
                    },
                },
                harper_ls = {
                    settings = {
                        ["harper-ls"] = {
                            linters = {
                                SentenceCapitalization = true,
                                SpellCheck = true 
                            },
                            dialect = "Canadian"
                        }
                    }
                },
                -- csharp_ls = {},
                zls = {},
                clangd = {
                    settings = {
                        ["clang"] = {
                            cmd = { "clangd", "--background-index", "--compile-commands-dir=" .. vim.loop.cwd() .. "/build" },
                        }
                    }
                },
                rust_analyzer= { 
                    settings = {
                        ['rust-analyzer'] = {
                            cargo = {
                                allFeatures = true,
                            },
                            checkOnSave = true,
                            check = {
                                command = "clippy",
                            },
                            procMacro = {
                                enable = true,
                            },
                            lens = {
                                debug = { enable = true },
                                enable = true,
                                implementations = { enable = true },
                                references = {
                                    adt = { enable = true },
                                    enumVariant = { enable = true },
                                    method = { enable = true },
                                    trait = { enable = true },
                                },
                                run = { enable = true },
                                updateTest = { enable = true },
                            },
                        },
                    }
                },
                ts_ls= {},
                html= {},
                eslint= {},
                jsonls= {},
                jdtls= {},
                copilot = {
                --     settings = {
                --         ['copilot'] = {
                --             cmd = { "copilot-language-server", "--stdio" },
                --             init_options = {
                --                 name = "Neovim",
                --                 version = tostring(vim.version()),
                --             },
                --             editorPluginInfo = {
                --                 name =  "Neovim",
                --                 version = tostring(vim.version()),
                --             },
                --         },
                --     },
                },
            }

            local ensure_installed = vim.tbl_keys(servers or {})
            require('mason-tool-installer').setup ({ ensure_installed = ensure_installed })

            local capabilities = vim.lsp.protocol.make_client_capabilities()
            capabilities = vim.tbl_deep_extend('force', capabilities, require('blink.cmp').get_lsp_capabilities({}, false))
            capabilities = vim.tbl_deep_extend('force', capabilities, {
                general = {
                    -- dynamicRegistration = false,
                    positionEncodings = { "utf-16" },
                },
                textDocument = {
                    foldingRange = {
                        dynamicRegistration = false,
                        lineFoldingOnly = true
                    }
                }
            })

            for server, cfg in pairs(servers) do
                cfg.capabilities = vim.tbl_deep_extend('force', {}, capabilities, cfg.capabilities or {})
                vim.lsp.config(server, cfg)
                vim.lsp.enable(server)
            end
            vim.lsp.inline_completion.enable();
            -- vim.lsp.enable("rust-analyzer", false)


        end
    },
    { 
        "rcarriga/nvim-dap-ui", 
        dependencies = {
            "mfussenegger/nvim-dap", 
            "nvim-neotest/nvim-nio"
        }, 
        config = function()
            local dapui = require("dapui")
            local dap = require("dap")
            dapui.setup()
            vim.fn.sign_define("DapBreakpoint", { text = "🐞" })

            dap.listeners.before.attach.dapui_config = function()
                dapui.open()
            end
            dap.listeners.before.launch.dapui_config = function()
                dapui.open()
            end
            dap.listeners.before.event_terminated.dapui_config = function()
                dapui.close()
            end
            dap.listeners.before.event_exited.dapui_config = function()
                dapui.close()
            end
        end
    },
    { 
        "jay-babu/mason-nvim-dap.nvim", 
        config = function()
            require ('mason-nvim-dap').setup({
                handlers = {
                    function(config)
                        -- all sources with no handler get passed here
                        -- Keep original functionality
                        require('mason-nvim-dap').default_setup(config)
                    end,
                },
            })
        end,
    },
    {
        "Saecki/crates.nvim",
        lazy = true,
        keys = function()
            local crates = require("crates")
            local opts = { silent = true }

            vim.keymap.set("n", "<leader>cct", crates.toggle, { desc = 'toggle' })
            vim.keymap.set("n", "<leader>ccr", crates.reload, { desc = 'reload' })
            vim.keymap.set("n", "<leader>ccv", crates.show_versions_popup, { desc = 'show versions' })
            vim.keymap.set("n", "<leader>ccf", crates.show_features_popup, { desc = 'show features' })
            vim.keymap.set("n", "<leader>ccd", crates.show_dependencies_popup, { desc = 'show dependencies' })
            vim.keymap.set("n", "<leader>ccu", crates.update_crate, { desc = 'update' })
            vim.keymap.set("v", "<leader>ccu", crates.update_crates, { desc = 'update' })
            vim.keymap.set("n", "<leader>cca", crates.update_all_crates, { desc = 'update all' })
            vim.keymap.set("n", "<leader>ccU", crates.upgrade_crate, { desc = 'upgrade' })
            vim.keymap.set("v", "<leader>ccU", crates.upgrade_crates, { desc = 'upgrade' })
            vim.keymap.set("n", "<leader>ccA", crates.upgrade_all_crates, { desc = 'upgrade all' })
            vim.keymap.set("n", "<leader>ccx", crates.expand_plain_crate_to_inline_table, { desc = 'expand' })
            vim.keymap.set("n", "<leader>ccX", crates.extract_crate_into_table, { desc = 'extract' })
            vim.keymap.set("n", "<leader>ccH", crates.open_homepage, { desc = 'open homepage' })
            vim.keymap.set("n", "<leader>ccR", crates.open_repository, { desc = 'open repository' })
            vim.keymap.set("n", "<leader>ccD", crates.open_documentation, { desc = 'open documents' })
            vim.keymap.set("n", "<leader>ccC", crates.open_crates_io, { desc = 'open crates.io' })
            vim.keymap.set("n", "<leader>ccL", crates.open_lib_rs, { desc = 'open lib.rs' })
        end,
        opts = {
            completion = {
                crates = {
                    enabled = true,
                },
            },
            lsp = {
                enabled = true,
                actions = true,
                completion = true,
                hover = true,
            },
        },
    },
    -- {
    --     'mrcjkb/rustaceanvim',
    --     -- version = '^6', -- Recommended
    --     lazy = true,
    --     ft = {'rust'},
    --     opts = {
    --         server = {
    --             default_settings = {
    --                 cargo = {
    --                     allFeatures = false,
    --                     loadOutDirsFromCheck = true,
    --                     buildScripts = { enable = true },
    --                 },
    --             },
    --             on_attach = function(_, bufnr)
    --                 vim.keymap.set("n", "<leader>lr", function()
    --                     vim.cmd.RustLsp("codeAction")
    --                 end, { desc = "Code Action", buffer = bufnr })
    --                 vim.keymap.set("n", "<leader>ld", function()
    --                     vim.cmd.RustLsp("debuggables")
    --                 end, { desc = "Rust Debuggables", buffer = bufnr })
    --                 vim.keymap.set("n", "<leader>lD", function()
    --                     vim.cmd.RustLsp("openDocs")
    --                 end, { desc = "Open Documents", buffer = bufnr })
    --                 vim.keymap.set("n", "<leader>lc", function()
    --                     vim.cmd.RustLsp("openCargo")
    --                 end, { desc = "Open Documents", buffer = bufnr })
    --             end,
    --         },
    --     },
    --     config = function(_, opts)
    --         vim.g.rustaceanvim = vim.tbl_deep_extend("keep", vim.g.rustaceanvim or {}, opts or {})
    --     end,
    -- },
    {
        -- Highlight, edit, and navigate code
        'nvim-treesitter/nvim-treesitter',
        build = ':TSUpdate',
        branch = 'main',
        dependencies = {
            -- 'p00f/nvim-ts-rainbow',
        },
        config = function()
            local ts_parsers = {
                "bash",
                "dockerfile",
                "git_config", "git_rebase", "gitattributes", "gitcommit", "gitignore",
                "go", "gomod", "gosum",
                "json", "toml", "yaml",
                "lua",
                "make",
                "markdown",
                "python",
                "terraform",
                "vim", "vimdoc",
                'c',
                "lua",
                "markdown",
                "markdown_inline",
                "query",
                "html", "xml",
                "zig",
                "typescript", "javascript", "svelte",
                "regex",
                "rust",
                "http",
            }

            local nts = require("nvim-treesitter")
            nts.install(ts_parsers)
            -- vim.api.nvim_create_autocmd('PackChanged', { 
            --     callback = function()
            --         nts.update()
            --     end
            -- })

            vim.api.nvim_create_autocmd("FileType", { -- enable treesitter highlighting and indents
                callback = function(args)
                    local filetype = args.match
                    local lang = vim.treesitter.language.get_lang(filetype)
                    if vim.treesitter.language.add(lang) then
                        vim.bo.indentexpr = "v:lua.require'nvim-treesitter'.indentexpr()"
                        vim.treesitter.start()
                    end
                end
            })

            -- vim.api.nvim_create_autocmd('FileType', {
            --     pattern = ts_parsers,
            --     callback = function() 
            --         vim.treesitter.start() 
            --     end,
            -- })
        end,
    },
    { 
        'nvim-treesitter/nvim-treesitter-textobjects',
        branch = "main",
        init = function()
            vim.g.no_plugin_maps = true
        end,
    },
    {
        'JoosepAlviste/nvim-ts-context-commentstring',
        lazy = true,
        opts = {
            enable_autocmd = false,
        }
    },
    {
        'nvim-treesitter/nvim-treesitter-context',
        enabled = true,
        config = function ()
            require("treesitter-context").setup({
                mode = "cursor", 
                max_lines = 3,
                multiline_threshold = 1,
                separator = '-',
                min_window_height = 20,
                line_numbers = true,
            })
        end,
    },
    {
        "mbbill/undotree",
        lazy = true,
        keys = {
            { '<leader>uu', vim.cmd.UndotreeToggle, desc = 'Format buffer' }
        },
    },
    {
        'Civitasv/cmake-tools.nvim',
        lazy = true,
        config = function ()
            local osys = require("cmake-tools.osys")
            require("cmake-tools").setup {
                cmake_command = "cmake", -- this is used to specify cmake command path
                ctest_command = "ctest", -- this is used to specify ctest command path
                cmake_use_preset = true,
                cmake_regenerate_on_save = true, -- auto generate when save CMakeLists.txt
                cmake_generate_options = { "-DCMAKE_EXPORT_COMPILE_COMMANDS=1" }, -- this will be passed when invoke `CMakeGenerate`
                cmake_build_options = {}, -- this will be passed when invoke `CMakeBuild`
                -- support macro expansion:
                --       ${kit}
                --       ${kitGenerator}
                --       ${variant:xx}
                cmake_build_directory = function()
                    if osys.iswin32 then
                        return "out\\${variant:buildType}"
                    end
                    return "out/${variant:buildType}"
                end, -- this is used to specify generate directory for cmake, allows macro expansion, can be a string or a function returning the string, relative to cwd.
                cmake_soft_link_compile_commands = true, -- this will automatically make a soft link from compile commands file to project root dir
                cmake_compile_commands_from_lsp = false, -- this will automatically set compile commands file location using lsp, to use it, please set `cmake_soft_link_compile_commands` to false
                cmake_kits_path = nil, -- this is used to specify global cmake kits path, see CMakeKits for detailed usage
                cmake_variants_message = {
                    short = { show = true }, -- whether to show short message
                    long = { show = true, max_length = 40 }, -- whether to show long message
                },
                cmake_dap_configuration = { -- debug settings for cmake
                    name = "cpp",
                    type = "codelldb",
                    request = "launch",
                    stopOnEntry = false,
                    runInTerminal = true,
                    console = "integratedTerminal",
                },
                cmake_executor = { -- executor to use
                    name = "quickfix", -- name of the executor
                    opts = {}, -- the options the executor will get, possible values depend on the executor type. See `default_opts` for possible values.
                    default_opts = { -- a list of default and possible values for executors
                        quickfix = {
                            show = "always", -- "always", "only_on_error"
                            position = "belowright", -- "vertical", "horizontal", "leftabove", "aboveleft", "rightbelow", "belowright", "topleft", "botright", use `:h vertical` for example to see help on them
                            size = 10,
                            encoding = "utf-8", -- if encoding is not "utf-8", it will be converted to "utf-8" using `vim.fn.iconv`
                            auto_close_when_success = true, -- typically, you can use it with the "always" option; it will auto-close the quickfix buffer if the execution is successful.
                        },
                        toggleterm = {
                            direction = "float", -- 'vertical' | 'horizontal' | 'tab' | 'float'
                            close_on_exit = false, -- whether close the terminal when exit
                            auto_scroll = true, -- whether auto scroll to the bottom
                            singleton = true, -- single instance, autocloses the opened one, if present
                        },
                        overseer = {
                            new_task_opts = {
                                strategy = {
                                    "toggleterm",
                                    direction = "horizontal",
                                    autos_croll = true,
                                    quit_on_exit = "success"
                                }
                            }, -- options to pass into the `overseer.new_task` command
                            on_new_task = function(task)
                                require("overseer").open(
                                    { enter = false, direction = "right" }
                                )
                            end,   -- a function that gets overseer.Task when it is created, before calling `task:start`
                        },
                        terminal = {
                            name = "Main Terminal",
                            prefix_name = "[CMakeTools]: ", -- This must be included and must be unique, otherwise the terminals will not work. Do not use a simple spacebar " ", or any generic name
                            split_direction = "horizontal", -- "horizontal", "vertical"
                            split_size = 11,

                            -- Window handling
                            single_terminal_per_instance = true, -- Single viewport, multiple windows
                            single_terminal_per_tab = true, -- Single viewport per tab
                            keep_terminal_static_location = true, -- Static location of the viewport if avialable
                            auto_resize = true, -- Resize the terminal if it already exists

                            -- Running Tasks
                            start_insert = false, -- If you want to enter terminal with :startinsert upon using :CMakeRun
                            focus = false, -- Focus on terminal when cmake task is launched.
                            do_not_add_newline = false, -- Do not hit enter on the command inserted when using :CMakeRun, allowing a chance to review or modify the command before hitting enter.
                        }, -- terminal executor uses the values in cmake_terminal
                    },
                },
                cmake_runner = { -- runner to use
                    name = "terminal", -- name of the runner
                    opts = {}, -- the options the runner will get, possible values depend on the runner type. See `default_opts` for possible values.
                    default_opts = { -- a list of default and possible values for runners
                        quickfix = {
                            show = "always", -- "always", "only_on_error"
                            position = "belowright", -- "bottom", "top"
                            size = 10,
                            encoding = "utf-8",
                            auto_close_when_success = true, -- typically, you can use it with the "always" option; it will auto-close the quickfix buffer if the execution is successful.
                        },
                        toggleterm = {
                            direction = "float", -- 'vertical' | 'horizontal' | 'tab' | 'float'
                            close_on_exit = false, -- whether close the terminal when exit
                            auto_scroll = true, -- whether auto scroll to the bottom
                            singleton = true, -- single instance, autocloses the opened one, if present
                        },
                        overseer = {
                            new_task_opts = {
                                strategy = {
                                    "toggleterm",
                                    direction = "horizontal",
                                    autos_croll = true,
                                    quit_on_exit = "success"
                                }
                            }, -- options to pass into the `overseer.new_task` command
                            on_new_task = function(task)
                            end,   -- a function that gets overseer.Task when it is created, before calling `task:start`
                        },
                        terminal = {
                            name = "Main Terminal",
                            prefix_name = "[CMakeTools]: ", -- This must be included and must be unique, otherwise the terminals will not work. Do not use a simple spacebar " ", or any generic name
                            split_direction = "horizontal", -- "horizontal", "vertical"
                            split_size = 11,

                            -- Window handling
                            single_terminal_per_instance = true, -- Single viewport, multiple windows
                            single_terminal_per_tab = true, -- Single viewport per tab
                            keep_terminal_static_location = true, -- Static location of the viewport if avialable
                            auto_resize = true, -- Resize the terminal if it already exists

                            -- Running Tasks
                            start_insert = false, -- If you want to enter terminal with :startinsert upon using :CMakeRun
                            focus = false, -- Focus on terminal when cmake task is launched.
                            do_not_add_newline = false, -- Do not hit enter on the command inserted when using :CMakeRun, allowing a chance to review or modify the command before hitting enter.
                        },
                    },
                },
                cmake_notifications = {
                    runner = { enabled = true },
                    executor = { enabled = true },
                    spinner = { "⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏" }, -- icons used for progress display
                    refresh_rate_ms = 100, -- how often to iterate icons
                },
                cmake_virtual_text_support = true, -- Show the target related to current file using virtual text (at right corner)
            }
        end,
    },
    {
        "folke/persistence.nvim",
        event = "BufReadPre",
        opts = { options = { "buffers", "curdir", "tabpages", "winsize", "help", "globals", "skiprtp" } },
        -- stylua: ignore
        keys = {
            { "<leader>xr", function() require("persistence").load() end, desc = "Restore Session" },
            { "<leader>xs", function() require("persistence").save() end, desc = "Save Session" },
            { "<leader>xl", function() require("persistence").load({ last = true }) end, desc = "Restore Last Session" },
            { "<leader>xd", function() require("persistence").stop() end, desc = "Don't Save Current Session" },
        },
    },

    {
        "otavioschwanck/arrow.nvim",
        dependencies = {
            {
                "nvim-tree/nvim-web-devicons"
            },
            -- or if using `mini.icons`
            -- { "echasnovski/mini.icons" },
        },
        opts = {
            show_icons = true,
            leader_key = ';', -- Recommended to be a single key
            buffer_leader_key = '<leader>;', -- Per Buffer Mappings
        }
    },
    {
        "nvim-pack/nvim-spectre",
        lazy = true,
        cmd = { "Spectre" },
        keys = {
            { "<leader>sr", function() require("spectre").open() end, desc = "Replace in files (Spectre)" },
        },
        opts = { 
            open_cmd = "noswapfile vnew",
            highlight = {
                search = "SpectreSearch",
                replace = "SpectreReplace",
            },
            mapping = {
                ["send_to_qf"] = {
                    map = "<C-q>",
                    cmd = "<cmd>lua require('spectre.actions').send_to_qf()<CR>",
                    desc = "send all items to quickfix",
                },
            },
        }
    },
    {
        'stevearc/overseer.nvim',
        keys = {
            { "<leader>xo", "<cmd>OverseerOpen<CR>", desc = "Open Overseer" },
            { "<leader>to", "<cmd>OverseerToggle<CR>", desc = "Overseer Toggle" },
            { "<F5>", "<cmd>OverseerRun<CR>", desc = "Run Overseer" },
            { "<F6>", "<cmd>OverseerToggle<CR>", desc = "Overseer Toggle" },
        },
        config = function()
            require("overseer").setup({
                templates = { "builtin", "user" },
                component_aliases = {
                    default = {
                        { 'display_duration', detail_level = 2 },
                        'on_output_summarize',
                        'on_exit_set_status',
                        'on_result_diagnostics_quickfix',
                        'on_complete_notify',
                        { "on_complete_dispose", require_view = { "SUCCESS", "FAILURE" } },
                    },
                    default_vscode = {
                        'default',
                        'on_result_diagnostics',
                        'on_result_diagnostics_quickfix',
                        'on_complete_notify',
                    },
                }
            })
            -- local pm = require("overseer.template.vscode.problem_matcher")
            -- pm.register_problem_matcher("$rustc", {
            --      fileLocation = { "autoDetect", "${cwd}" },
            --      pattern = {
            --          --regexp = "^(.*?)-->\\s+(.*?):(\\d+):(\\d+)$",
            --          -- vim_regexp = "\\v^(.*?)-->\\s+(.*?):(\\d+):(\\d+)$",
            --          regexp = "^\\s+-->\\s*([^:]*):(\\d+):(\\d+)$",
            --          vim_regexp = "\\v^\\s+-->\\s*([^:]*):(\\d+):(\\d+)$",
            --          file = 1,
            --          line = 2,
            --          column = 3,
            --      }
            -- })

        end,
    },

}