install scripts. reorganization. soon to be deployable

env/.config/nvim/.luarc.json

@@ -0,0 +1,14 @@
+{
+  "runtime.version": "LuaJIT",
+  "runtime.path": [
+    "lua/?.lua",
+    "lua/?/init.lua"
+  ],
+  "diagnostics.globals": ["vim",
+        "endclose_tag_on_exit"],
+  "workspace.checkThirdParty": false,
+  "workspace.library": [
+    "$VIMRUNTIME",
+    "./lua"
+  ]
+}

env/.config/nvim/after/plugin/3rd.lua

@@ -0,0 +1,41 @@
+require("image").setup({
+    backend = "kitty",
+    processor = "magick_cli", -- or "magick_rock"
+    integrations = {
+        markdown = {
+            enabled = true,
+            clear_in_insert_mode = false,
+            download_remote_images = false,
+            only_render_image_at_cursor = true,
+            only_render_image_at_cursor_mode = "popup",
+            floating_windows = false, -- if true, images will be rendered in floating markdown windows
+            filetypes = { "markdown", "vimwiki" }, -- markdown extensions (ie. quarto) can go here
+        },
+        neorg = {
+            enabled = true,
+            filetypes = { "norg" },
+        },
+        typst = {
+            enabled = true,
+            filetypes = { "typst" },
+        },
+        html = {
+            enabled = false,
+        },
+        css = {
+            enabled = false,
+        },
+    },
+    max_width = nil,
+    max_height = nil,
+    max_width_window_percentage = nil,
+    max_height_window_percentage = 50,
+    window_overlap_clear_enabled = false, -- toggles images when windows are overlapped
+    window_overlap_clear_ft_ignore = { "cmp_menu", "cmp_docs", "snacks_notif", "scrollview", "scrollview_sign" },
+    editor_only_render_when_focused = false, -- auto show/hide images when the editor gains/looses focus
+    tmux_show_only_in_active_window = false, -- auto show/hide images in the correct Tmux window (needs visual-activity off)
+    hijack_file_patterns = { "*.png", "*.jpg", "*.jpeg", "*.gif", "*.webp", "*.avif" }, -- render image files as images when opened
+})
+
+-- require("image").enable() -- enable the plugin
+-- print(require("image").is_enabled()) -- bool

env/.config/nvim/after/plugin/cloak.lua

@@ -0,0 +1,31 @@
+require('yourmom/cloak').setup({
+    enabled = true,
+    cloak_character = '*',
+    -- The applied highlight group (colors) on the cloaking, see `:h highlight`.
+    highlight_group = 'Comment',
+    -- Applies the length of the replacement characters for all matched
+    -- patterns, defaults to the length of the matched pattern.
+    cloak_length = nil, -- Provide a number if you want to hide the true length of the value.
+    -- Whether it should try every pattern to find the best fit or stop after the first.
+    try_all_patterns = true,
+    -- Set to true to cloak Telescope preview buffers. (Required feature not in 0.1.x)
+    cloak_telescope = true,
+    -- Re-enable cloak when a matched buffer leaves the window.
+    cloak_on_leave = false,
+    patterns = {
+        {
+            -- Match any file starting with '.env'.
+            -- This can be a table to match multiple file patterns.
+            file_pattern = '.env*',
+            -- Match an equals sign and any character after it.
+            -- This can also be a table of patterns to cloak,
+            -- example: cloak_pattern = { ':.+', '-.+' } for yaml files.
+            cloak_pattern = '=.+',
+            -- A function, table or string to generate the replacement.
+            -- The actual replacement will contain the 'cloak_character'
+            -- where it doesn't cover the original text.
+            -- If left empty the legacy behavior of keeping the first character is retained.
+            replace = nil,
+        }
+    },
+})

env/.config/nvim/after/plugin/colorizer.lua

@@ -0,0 +1 @@
+require("colorizer").setup()

env/.config/nvim/after/plugin/hardtime.lua

@@ -0,0 +1 @@
+require("hardtime").setup()

env/.config/nvim/after/plugin/harpoon.lua

@@ -0,0 +1,11 @@
+local mark = require("harpoon.mark")
+local ui = require("harpoon.ui")
+
+vim.keymap.set("n","<leader>a", mark.add_file)
+vim.keymap.set("n","<C-e>", ui.toggle_quick_menu)
+
+
+vim.keymap.set("n","<C-y>", function() ui.nav_file(1) end)
+vim.keymap.set("n","<C-t>", function() ui.nav_file(2) end)
+vim.keymap.set("n","<C-n>", function() ui.nav_file(3) end)
+vim.keymap.set("n","<C-s>", function() ui.nav_file(4) end)

env/.config/nvim/after/plugin/indent-blankline.lua

@@ -0,0 +1,30 @@
+local highlight = {
+    "RainbowRed",
+}
+
+local hooks = require "ibl.hooks"
+-- create the highlight groups in the highlight setup hook, so they are reset
+-- every time the colorscheme changes
+hooks.register(hooks.type.HIGHLIGHT_SETUP, function()
+    vim.api.nvim_set_hl(0, "RainbowRed", { fg = "#702ec0" })
+end)
+
+require('ibl').setup {
+    indent = {
+        char = '|',
+        highlight = highlight,
+    },
+    scope = {
+        show_start = false,
+        show_end = false,
+        show_exact_scope = false,
+    },
+    exclude = {
+        filetypes = {
+            'help',
+            'packer',
+            'undotree',
+            'diff',
+        },
+    },
+}

env/.config/nvim/after/plugin/lsp.lua

@@ -0,0 +1,75 @@
+vim.api.nvim_create_autocmd("FileType", {
+  pattern = "src",
+  callback = function()
+    print("LSP should now be active for src files")
+  end,
+})
+
+local lsp = require("lsp-zero")
+
+lsp.preset("recommended")
+
+
+local cmp = require('cmp')
+
+local cmp_select = {behavior = cmp.SelectBehavior.Select}
+local cmp_mappings = cmp.mapping.preset.insert({
+  ['<C-p>'] = cmp.mapping.select_prev_item(cmp_select),
+  ['<C-n>'] = cmp.mapping.select_next_item(cmp_select),
+  ['<C-y>'] = cmp.mapping.confirm({ select = true }),
+  ["<C-Space>"] = cmp.mapping.complete(),
+})
+
+cmp.setup({
+	mapping = cmp_mappings,
+})
+
+vim.diagnostic.config({
+    virtual_text = true,
+})
+
+lsp.on_attach(function(client, bufnr)
+  local opts = {buffer = bufnr, remap = false}
+
+  vim.keymap.set("n", "gd", function() vim.lsp.buf.definition() end, opts)
+  vim.keymap.set("n", "K", function() vim.lsp.buf.hover() end, opts)
+  vim.keymap.set("n", "<leader>vws", function() vim.lsp.buf.workspace_symbol() end, opts)
+  vim.keymap.set("n", "<leader>vd", function() vim.diagnostic.open_float() end, opts)
+  vim.keymap.set("n", "[d", function() vim.diagnostic.goto_next() end, opts)
+  vim.keymap.set("n", "]d", function() vim.diagnostic.goto_prev() end, opts)
+  vim.keymap.set("n", "<leader>vca", function() vim.lsp.buf.code_action() end, opts)
+  vim.keymap.set("n", "<leader>vrr", function() vim.lsp.buf.references() end, opts)
+  vim.keymap.set("n", "<leader>vrn", function() vim.lsp.buf.rename() end, opts)
+  vim.keymap.set("i", "<C-h>", function() vim.lsp.buf.signature_help() end, opts)
+end)
+
+
+local lsp_configurations = require('lspconfig.configs')
+
+if not lsp_configurations.greybel then
+  lsp_configurations.greybel = {
+    default_config = {
+        cmd = { "/bin/greybel-languageserver", "--stdio" },
+        filetypes = { "greyscript" },
+        root_dir = require('lspconfig.util').root_pattern(".git", vim.fn.getcwd()),
+        settings = {},
+    }
+  }
+end
+
+-- to learn how to use mason.nvim with lsp-zero
+-- read this: https://github.com/VonHeikemen/lsp-zero.nvim/blob/v3.x/doc/md/guides/integrate-with-mason-nvim.md
+require('mason').setup({
+    registries = {
+        "github:mason-org/mason-registry",
+    },
+})
+require('mason-lspconfig').setup({
+  ensure_installed = { },
+  handlers = {
+    lsp.default_setup,
+  },
+})
+require('lspconfig').greybel.setup({})
+
+lsp.setup()

env/.config/nvim/after/plugin/lualine.lua

@@ -0,0 +1,46 @@
+require('lualine').setup()
+
+local custom_gruvbox = require'lualine.themes.base16'
+
+-- Change the background of lualine_c section for normal mode
+custom_gruvbox.normal.c.bg = '#222222'
+
+local hide_in_width = function()
+    return vim.fn.winwidth(0) > 80
+end
+
+local diagnostics = {
+    'diagnostics',
+    sources = { 'nvim_diagnostic' },
+    sections = { 'error' , 'warn' },
+    symbols = { error = ' ', warn = ' ', info = ' ', hint = ' ' },
+    update_in_insert = false,
+    allways_visible = false,
+    cond = hide_in_width,
+}
+
+require('lualine').setup {
+    options = {
+        theme  = custom_gruvbox,
+        icons_enabled = true,
+        disabled_filetypes = {'undotree', 'diff'},
+    },
+    sections = {
+        lualine_a = {{
+            'mode',
+            fmt = function(str)
+                return ' ' .. str
+            end,
+        }},
+        lualine_b = {'branch', 'diff', diagnostics},
+        lualine_c = {{
+            'filename',
+            file_status = true,
+            path = 0,
+        }},
+        --lualine_x = {'encoding', 'fileformat', 'filetype'},
+        lualine_x = {{'encoding', cond=hide_in_width}, {'filetype',cond=hide_in_width}},
+        lualine_y = {'progress'},
+        lualine_z = {'location'}
+    }
+}

env/.config/nvim/after/plugin/notify.lua

@@ -0,0 +1,4 @@
+vim.notify = require("notify")
+require("notify").setup({
+    background_colour="#000000"
+})

env/.config/nvim/after/plugin/telescope.lua

@@ -0,0 +1,9 @@
+local builtin = require('telescope.builtin')
+vim.keymap.set('n', '<leader>pf', builtin.find_files, {})
+vim.keymap.set('n', '<leader>pg', builtin.live_grep, {})
+vim.keymap.set('n', '<leader>pb', builtin.buffers, {})
+vim.keymap.set('n', '<leader>ph', builtin.help_tags, {})
+vim.keymap.set('n', '<leader>ps', function()
+	builtin.grep_string({ search = vim.fn.input("Grep > ") });
+end)
+--vim.keymap.set('n', '<C-p>', builtin.git_files, {})

env/.config/nvim/after/plugin/undotree.lua

@@ -0,0 +1 @@
+vim.keymap.set("n", "<leader>u", vim.cmd.UndotreeToggle)

env/.config/nvim/custom-lsp/.luarc.json

@@ -0,0 +1,3 @@
+{
+    "workspace.library":["~/.config/nvim/custom-lsp"]
+}

env/.config/nvim/init.lua

@@ -0,0 +1 @@
+require("yourmom")

env/.config/nvim/lua/yourmom/cloak.lua

@@ -0,0 +1,293 @@
+local group = vim.api.nvim_create_augroup('cloak', {})
+local namespace = vim.api.nvim_create_namespace('cloak')
+
+-- In case cmp is lazy loaded, we check :CmpStatus instead of a pcall to require
+-- so we maintain the lazy load.
+local has_cmp = function()
+  return vim.fn.exists(':CmpStatus') > 0
+end
+
+local M = {}
+
+M.opts = {
+  enabled = true,
+  cloak_character = '*',
+  cloak_length = nil,
+  highlight_group = 'Comment',
+  try_all_patterns = true,
+  patterns = { { file_pattern = '.env*', cloak_pattern = '=.+' } },
+  cloak_telescope = true,
+  uncloaked_line_num = nil,
+  cloak_on_leave = false,
+}
+
+M.setup = function(opts)
+  M.opts = vim.tbl_deep_extend('force', M.opts, opts or {})
+  vim.b.cloak_enabled = M.opts.enabled
+
+  for _, pattern in ipairs(M.opts.patterns) do
+    if type(pattern.cloak_pattern) == 'string' then
+      pattern.cloak_pattern = { { pattern.cloak_pattern, replace = pattern.replace } }
+    else
+      for i, inner_pattern in ipairs(pattern.cloak_pattern) do
+        pattern.cloak_pattern[i] =
+          type(inner_pattern) == 'string'
+            and { inner_pattern, replace = pattern.cloak_pattern.replace or pattern.replace }
+            or inner_pattern
+      end
+    end
+
+    vim.api.nvim_create_autocmd(
+      { 'BufEnter', 'TextChanged', 'TextChangedI', 'TextChangedP' }, {
+        pattern = pattern.file_pattern,
+        callback = function()
+          if M.opts.enabled then
+            M.cloak(pattern)
+          else
+            M.uncloak()
+          end
+        end,
+        group = group,
+      }
+    )
+
+    if M.opts.cloak_on_leave then
+      vim.api.nvim_create_autocmd(
+        'BufWinLeave', {
+          pattern = pattern.file_pattern,
+          callback = function()
+            M.enable()
+          end,
+          group = group,
+        }
+      )
+    end
+  end
+
+  if M.opts.cloak_telescope then
+    vim.api.nvim_create_autocmd(
+      'User', {
+        pattern = 'TelescopePreviewerLoaded',
+        callback = function(args)
+          -- Feature not in 0.1.x
+          if not M.opts.enabled or args.data == nil then
+            return
+          end
+
+          local buffer = require('telescope.state').get_existing_prompt_bufnrs()[1]
+          local picker = require('telescope.actions.state').get_current_picker(
+            buffer
+          )
+
+          -- If our state variable is set, meaning we have just refreshed after cloaking a buffer,
+          -- set the selection to that row again.
+          if picker.__cloak_selection then
+            picker:set_selection(picker.__cloak_selection)
+            picker.__cloak_selection = nil
+            vim.schedule(
+              function()
+                picker:refresh_previewer()
+              end
+            )
+            return
+          end
+
+          local is_cloaked, _ = pcall(
+            vim.api.nvim_buf_get_var, args.buf, 'cloaked'
+          )
+
+          -- Check the buffer agains all configured patterns,
+          -- if matched, set a variable on the picker to know where we left off,
+          -- set a buffer variable to know we already cloaked it later, and refresh.
+          -- a refresh will result in the cloak being visible, and will make this
+          -- aucmd be called again right away with the first result, which we will then
+          -- set to what we have stored in the code above.
+          if M.recloak_file(args.data.bufname) then
+            vim.api.nvim_buf_set_var(args.buf, 'cloaked', true)
+            if is_cloaked then
+              return
+            end
+
+            local row = picker:get_selection_row()
+            picker.__cloak_selection = row
+            picker:refresh()
+            return
+          end
+        end,
+        group = group,
+      }
+    )
+  end
+  -- Handle cloaking the Telescope preview.
+
+  vim.api.nvim_create_user_command('CloakEnable', M.enable, {})
+  vim.api.nvim_create_user_command('CloakDisable', M.disable, {})
+  vim.api.nvim_create_user_command('CloakToggle', M.toggle, {})
+  vim.api.nvim_create_user_command('CloakPreviewLine', M.uncloak_line, {})
+end
+
+M.uncloak = function()
+  vim.api.nvim_buf_clear_namespace(0, namespace, 0, -1)
+end
+
+M.uncloak_line = function()
+  if not M.opts.enabled then
+    return
+  end
+
+  local buf = vim.api.nvim_win_get_buf(0)
+  local cursor = vim.api.nvim_win_get_cursor(0)
+  M.opts.uncloaked_line_num = cursor[1]
+
+  vim.api.nvim_create_autocmd(
+    { 'CursorMoved', 'CursorMovedI', 'BufLeave' }, {
+      buffer = buf,
+      callback = function(args)
+        if not M.opts.enabled then
+          M.opts.uncloaked_line_num = nil
+          return true
+        end
+
+        if args.event == 'BufLeave' then
+          M.opts.uncloaked_line_num = nil
+          M.recloak_file(vim.api.nvim_buf_get_name(buf))
+          return true
+        end
+
+        local ncursor = vim.api.nvim_win_get_cursor(0)
+        if ncursor[1] == M.opts.uncloaked_line_num then
+          return
+        end
+
+        M.opts.uncloaked_line_num = nil
+        M.recloak_file(vim.api.nvim_buf_get_name(buf))
+
+        -- deletes the auto command
+        return true
+      end,
+      group = group,
+    }
+  )
+
+  M.recloak_file(vim.api.nvim_buf_get_name(buf))
+end
+
+M.cloak = function(pattern)
+  M.uncloak()
+
+  if has_cmp() then
+    require('cmp').setup.buffer({ enabled = false })
+  end
+
+  local function determine_replacement(length, prefix)
+    local cloak_str = prefix
+      .. M.opts.cloak_character:rep(
+        tonumber(M.opts.cloak_length)
+        or length - vim.fn.strchars(prefix))
+    local remaining_length = length - vim.fn.strchars(cloak_str)
+    -- Fixme:
+    -- - When cloak_length is longer than the text underlying it,
+    --   it results in overlaying of extra text
+    -- => Possiblie solutions would could be implemented using inline virtual text
+    --    (https://github.com/neovim/neovim/pull/20130)
+    return cloak_str -- :sub(1, math.min(remaining_length - 1, -1))
+      .. (' '):rep(remaining_length)
+  end
+
+  local found_pattern = false
+  local lines = vim.api.nvim_buf_get_lines(0, 0, -1, false)
+  for i, line in ipairs(lines) do
+    -- Find all matches for the current line
+    local searchStartIndex = 1
+    while searchStartIndex < #line and
+        -- if the line is uncloaked skip
+      i ~= M.opts.uncloaked_line_num do
+
+      -- Find best pattern based on starting position and tiebreak with length
+      local first, last, matching_pattern, has_groups = -1, 1, nil, false
+      for _, inner_pattern in ipairs(pattern.cloak_pattern) do
+        local current_first, current_last, capture_group =
+          line:find(inner_pattern[1], searchStartIndex)
+        if current_first ~= nil
+          and (first < 0
+            or current_first < first
+            or (current_first == first and current_last > last)) then
+          first, last, matching_pattern, has_groups =
+            current_first, current_last, inner_pattern, capture_group ~= nil
+          if M.opts.try_all_patterns == false then break end
+        end
+      end
+      if first >= 0 then
+        found_pattern = true
+        local prefix = line:sub(first,first)
+        if has_groups and matching_pattern.replace ~= nil then
+          prefix = line:sub(first,last)
+            :gsub(matching_pattern[1], matching_pattern.replace, 1)
+        end
+        local last_of_prefix = first + vim.fn.strchars(prefix) - 1
+        if prefix == line:sub(first, last_of_prefix) then
+          first, prefix = last_of_prefix + 1, ''
+        end
+        vim.api.nvim_buf_set_extmark(
+          0, namespace, i - 1, first-1, {
+            hl_mode = 'combine',
+            virt_text = {
+              {
+                determine_replacement(last - first + 1, prefix),
+                M.opts.highlight_group,
+              },
+            },
+            virt_text_pos = 'overlay',
+          }
+        )
+      else break end
+      searchStartIndex = last
+    end
+  end
+  if found_pattern then
+    vim.opt_local.wrap = false
+  end
+end
+
+M.recloak_file = function(filename)
+  local base_name = vim.fn.fnamemodify(filename, ':t')
+  for _, pattern in ipairs(M.opts.patterns) do
+    -- Could be a string or a table of patterns.
+    local file_patterns = pattern.file_pattern
+    if type(file_patterns) == 'string' then
+      file_patterns = { file_patterns }
+    end
+
+    for _, file_pattern in ipairs(file_patterns) do
+      if base_name ~= nil and
+        vim.fn.match(base_name, vim.fn.glob2regpat(file_pattern)) ~= -1 then
+        M.cloak(pattern)
+        return true
+      end
+    end
+  end
+
+  return false
+end
+
+M.disable = function()
+  M.uncloak()
+  M.opts.enabled = false
+  vim.b.cloak_enabled = false
+end
+
+M.enable = function()
+  M.opts.enabled = true
+  vim.b.cloak_enabled = true
+  vim.cmd('doautocmd TextChanged')
+end
+
+M.toggle = function()
+  if M.opts.enabled then
+    M.disable()
+  else
+    M.enable()
+  end
+end
+
+return M

env/.config/nvim/lua/yourmom/init.lua

@@ -0,0 +1,50 @@
+require("yourmom.remap")
+
+vim.opt.guicursor=""
+
+vim.opt.nu = true
+vim.opt.relativenumber = true
+
+vim.opt.tabstop = 4
+vim.opt.softtabstop = 4
+vim.opt.shiftwidth = 4
+vim.opt.expandtab = true
+
+vim.opt.smartindent=true
+
+vim.opt.wrap = true
+
+vim.opt.hlsearch = false
+vim.opt.incsearch = true
+
+vim.o.ignorecase = true
+
+vim.opt.updatetime = 50
+--vim.opt.colorcolumn = "80"
+--vim.cmd('colorscheme vim')
+--vim.cmd('colorscheme rose-pine')
+vim.api.nvim_set_hl(0, "Normal", { bg = "none" })
+vim.api.nvim_set_hl(0, "NormalFloat", { bg = "none" })
+
+
+vim.cmd('hi SignColumn ctermbg=0')
+vim.cmd('set signcolumn=no')
+
+vim.cmd('hi Pmenu ctermfg=120')
+vim.cmd('hi Pmenu ctermbg=0')
+
+vim.cmd('hi StatusLine ctermfg=0')
+vim.cmd('hi StatusLine ctermbg=15')
+vim.cmd('hi StatusLine cterm=reverse')
+
+vim.opt.termguicolors = true
+
+--allows highlighint in comments
+--vim.api.nvim_set_hl(0, '@lsp.type.comment.cpp', {})
+
+
+vim.filetype.add({
+    extension = {
+        src = "greyscript"
+    }
+})

env/.config/nvim/lua/yourmom/packer.lua

@@ -0,0 +1,73 @@
+-- This file can be loaded by calling `lua require('plugins')` from your init.vim
+
+-- Only required if you have packer configured as `opt`
+vim.cmd [[packadd packer.nvim]]
+
+return require('packer').startup(function(use)
+    -- Packer can manage itself
+
+    use 'wbthomason/packer.nvim'
+
+    use 'ThePrimeagen/vim-be-good'
+    use 'ThePrimeagen/harpoon'
+
+    use 'm4xshen/hardtime.nvim'
+
+    use 'rcarriga/nvim-notify'
+
+    use { "rose-pine/neovim", as = "rose-pine" }
+
+    use "jbyuki/quickmath.nvim"
+
+    use '3rd/image.nvim'
+
+    use {
+        'nvim-telescope/telescope.nvim', tag = '0.1.5',
+        -- or                            , branch = '0.1.x',
+        requires = { {'nvim-lua/plenary.nvim'} }
+    }
+
+    use("mbbill/undotree")
+
+    use "lukas-reineke/indent-blankline.nvim"
+
+    use({ "NStefan002/screenkey.nvim", tag = "*" })
+
+    use("catgoose/nvim-colorizer.lua")
+
+    use {
+        'nvim-lualine/lualine.nvim',
+        --requires = { 'nvim-tree/nvim-web-devicons', opt = true }
+    }
+
+--[[
+    use('nvim-treesitter/nvim-treesitter', {run = ':TSUpdate',
+        config = function()
+        require("nvim-treesitter.configs").setup {
+        ensure_installed = { "c", "lua", "rust" },
+        highlight = { enable = true, }
+        }
+        end
+        })
+    ]]--
+
+    use {
+        'VonHeikemen/lsp-zero.nvim',
+        branch = 'v3.x',
+        requires = {
+            --- Uncomment the two plugins below if you want to manage the language servers from neovim
+            {'williamboman/mason.nvim'},
+            {'williamboman/mason-lspconfig.nvim'},
+
+            -- LSP Support
+            {'neovim/nvim-lspconfig'},
+            -- Autocompletion
+            {'hrsh7th/nvim-cmp'},
+            {'hrsh7th/cmp-buffer'},
+            {'hrsh7th/cmp-path'},
+            {'hrsh7th/cmp-nvim-lsp'},
+            {'hrsh7th/cmp-nvim-lua'},
+            {'L3MON4D3/LuaSnip'},
+        }
+    }
+end)

env/.config/nvim/lua/yourmom/remap.lua

@@ -0,0 +1,262 @@
+vim.g.mapleader=" "
+vim.g.maplocalleader=" "
+vim.keymap.set("n", "<leader>pv", vim.cmd.Ex)
+
+
+--[[vim.cmd[[
+au VimEnter * silent! !xmodmap -e 'clear Lock' -e 'keycode 0x42 = Escape'
+au VimLeave * silent! !xmodmap -e 'clear Lock' -e 'keycode 0x42 = Caps_Lock'>
+]]
+
+
+--move highlighted stuffs
+vim.keymap.set("v", "J", ":m '>+1<CR>gv=gv")
+vim.keymap.set("v", "K", ":m '<-2<CR>gv=gv")
+
+--keeps cursor at cur pos when stacking lines to single line
+vim.keymap.set("n", "J", "mzJ`z")
+--keeps cursur in middle with up down
+vim.keymap.set("n", "<C-d>", "<C-d>zz")
+vim.keymap.set("n", "<C-u>", "<C-u>zz")
+vim.keymap.set("n", "n", "nzzzv")
+vim.keymap.set("n", "N", "Nzzzv")
+
+--sets leader y to put in sys clipboard
+vim.keymap.set("n", "<leader>y", "\"+y")
+vim.keymap.set("v", "<leader>y", "\"+y")
+vim.keymap.set("n", "<leader>Y", "\"+Y")
+--paste but dont overwrite current register with selection
+vim.keymap.set("v", "<leader>p", "\"_dP")
+
+--nnoremap S :%s//g<left><left>
+vim.keymap.set("n", "S", [[:%s//<Left>]])
+
+
+vim.keymap.set('n', '<leader>to', ':tabnew<CR>')
+vim.keymap.set('n', '<leader>tx', ':tabclose<CR>')
+vim.keymap.set('n', '<leader>tn', ':tabn<CR>')
+vim.keymap.set('n', '<leader>tp', ':tabp<CR>')
+
+vim.keymap.set('n', '<leader>lw', '<cmd>:set wrap!<CR>')
+
+--stay in indent mode
+vim.keymap.set('v', '<', '<gv', {noremap = true})
+vim.keymap.set('v', '>', '>gv', {noremap = true})
+
+
+--reize with arrows
+vim.keymap.set('n', '<A-k>', ':resize -2<CR>')
+vim.keymap.set('n', '<A-j>', ':resize +2<CR>')
+vim.keymap.set('n', '<A-h>', ':vertical resize -2<CR>')
+vim.keymap.set('n', '<A-l>', ':vertical resize +2<CR>')
+
+-- window management
+vim.keymap.set('n', '<leader>v', '<C-w>v')
+vim.keymap.set('n', '<leader>h', '<C-w>s')
+vim.keymap.set('n', '<leader>se', '<C-w>=')
+vim.keymap.set('n', '<leader>xs', ':close<CR>')
+
+-- navigate splits 
+vim.keymap.set("n","<C-h>","<C-w>h")
+vim.keymap.set("n","<C-j>","<C-w>j")
+vim.keymap.set("n","<C-l>","<C-w>l")
+vim.keymap.set("n","<C-k>","<C-w>k")
+
+
+
+vim.keymap.set("n", "<leader>ee", "oif err != nil {<CR>}<Esc>Oreturn err<Esc>")
+
+--per file type log quick binds
+local cc_command=""
+local filename = vim.api.nvim_buf_get_name(0)
+
+if string.find(filename,".*%.js$") then
+    cc_command="oconsole.log();<Esc>V=$hi"
+elseif string.find(filename,".*%.lua$") then
+    cc_command="oterm.print()<Esc>V=$i"
+elseif string.find(filename,".*%.c$") then
+    cc_command="oprintf(\"debug: %i\",);<Esc>V=$hi"
+elseif string.find(filename,".*%.rs$") then
+    cc_command="oprintln!(\"debug: {}\",);<Esc>V=$hi"
+end
+
+vim.keymap.set("n", "<leader>cc", cc_command)
+
+local auto_close=false
+local function toggle_auto_close()
+    if auto_close==false then
+        vim.keymap.set("i", "{", "{<CR>}<Esc>ko");
+        vim.keymap.set("i", "(", "()<Esc>i");
+        if string.find(filename,".*%.html$") then
+            vim.keymap.set("i", "<", "<");
+            vim.keymap.set("i", ">", "><Esc>T<yef>a</><Esc>hpF<i");
+        else
+            vim.keymap.set("i", "<", "<><Esc>i");
+            vim.keymap.set("i", ">", ">");
+        end
+        vim.keymap.set("i", "[", "[]<Esc>i");
+        vim.keymap.set("i", "\"", "\"\"<Esc>i");
+        vim.keymap.set("i", "'", "''<Esc>i");
+        auto_close=true
+    else
+        vim.keymap.set("i", "{", "{");
+        vim.keymap.set("i", "(", "(");
+        vim.keymap.set("i", "<", "<");
+        vim.keymap.set("i", ">", ">");
+        vim.keymap.set("i", "[", "[");
+        vim.keymap.set("i", "\"", "\"");
+        vim.keymap.set("i", "'", "'");
+        auto_close=false
+    end
+end
+toggle_auto_close()
+
+vim.keymap.set("n", "<leader>k", toggle_auto_close)
+
+--[[
+vim.keymap("i","<Caps_Lock>", function()
+	
+end)
+]]
+
+local colemak_switch=false
+
+local colemak_tog = function()
+    if colemak_switch==true then
+        colemak_switch=false
+        vim.keymap.set("n","d","d")
+        vim.keymap.set("n","e","e")
+        vim.keymap.set("n","f","f")
+        vim.keymap.set("n","g","g")
+        vim.keymap.set("n","i","i")
+        vim.keymap.set("n","j","j")
+        vim.keymap.set("n","k","k")
+        vim.keymap.set("n","l","l")
+        vim.keymap.set("n","n","n")
+        vim.keymap.set("n","o","o")
+        vim.keymap.set("n","p","p")
+        vim.keymap.set("n","r","r")
+        vim.keymap.set("n","s","s")
+        vim.keymap.set("n","t","t")
+        vim.keymap.set("n","u","u")
+        vim.keymap.set("n","y","y")
+        vim.keymap.set("n","D","D")
+        vim.keymap.set("n","E","E")
+        vim.keymap.set("n","F","F")
+        vim.keymap.set("n","G","G")
+        vim.keymap.set("n","I","I")
+        vim.keymap.set("n","J","J")
+        vim.keymap.set("n","K","K")
+        vim.keymap.set("n","L","L")
+        vim.keymap.set("n","N","N")
+        vim.keymap.set("n","O","O")
+        vim.keymap.set("n","P","P")
+        vim.keymap.set("n","R","R")
+        vim.keymap.set("n","S","S")
+        vim.keymap.set("n","T","T")
+        vim.keymap.set("n","U","U")
+        vim.keymap.set("n","Y","Y")
+
+        vim.keymap.set("v","d","d")
+        vim.keymap.set("v","e","e")
+        vim.keymap.set("v","f","f")
+        vim.keymap.set("v","g","g")
+        vim.keymap.set("v","i","i")
+        vim.keymap.set("v","j","j")
+        vim.keymap.set("v","k","k")
+        vim.keymap.set("v","l","l")
+        vim.keymap.set("v","n","n")
+        vim.keymap.set("v","o","o")
+        vim.keymap.set("v","p","p")
+        vim.keymap.set("v","r","r")
+        vim.keymap.set("v","s","s")
+        vim.keymap.set("v","t","t")
+        vim.keymap.set("v","u","u")
+        vim.keymap.set("v","y","y")
+        vim.keymap.set("v","D","D")
+        vim.keymap.set("v","E","E")
+        vim.keymap.set("v","F","F")
+        vim.keymap.set("v","G","G")
+        vim.keymap.set("v","I","I")
+        vim.keymap.set("v","J","J")
+        vim.keymap.set("v","K","K")
+        vim.keymap.set("v","L","L")
+        vim.keymap.set("v","N","N")
+        vim.keymap.set("v","O","O")
+        vim.keymap.set("v","P","P")
+        vim.keymap.set("v","R","R")
+        vim.keymap.set("v","S","S")
+        vim.keymap.set("v","T","T")
+        vim.keymap.set("v","U","U")
+        vim.keymap.set("v","Y","Y")
+    else
+        colemak_switch=true
+        vim.keymap.set("n","d","g")
+        vim.keymap.set("n","e","k")
+        vim.keymap.set("n","f","e")
+        vim.keymap.set("n","g","t")
+        vim.keymap.set("n","i","l")
+        vim.keymap.set("n","j","y")
+        vim.keymap.set("n","k","n")
+        vim.keymap.set("n","l","u")
+        vim.keymap.set("n","n","j")
+        vim.keymap.set("n","o","p")
+        vim.keymap.set("n","p","r")
+        vim.keymap.set("n","r","s")
+        vim.keymap.set("n","s","d")
+        vim.keymap.set("n","t","f")
+        vim.keymap.set("n","u","i")
+        vim.keymap.set("n","y","o")
+        vim.keymap.set("n","D","G")
+        vim.keymap.set("n","E","K")
+        vim.keymap.set("n","F","E")
+        vim.keymap.set("n","G","T")
+        vim.keymap.set("n","I","L")
+        vim.keymap.set("n","J","Y")
+        vim.keymap.set("n","K","N")
+        vim.keymap.set("n","L","U")
+        vim.keymap.set("n","N","J")
+        vim.keymap.set("n","O","P")
+        vim.keymap.set("n","P","R")
+        vim.keymap.set("n","R","S")
+        vim.keymap.set("n","S","D")
+        vim.keymap.set("n","T","F")
+        vim.keymap.set("n","U","I")
+        vim.keymap.set("n","Y","O")
+
+        vim.keymap.set("v","d","g")
+        vim.keymap.set("v","e","k")
+        vim.keymap.set("v","f","e")
+        vim.keymap.set("v","g","t")
+        vim.keymap.set("v","i","l")
+        vim.keymap.set("v","j","y")
+        vim.keymap.set("v","k","n")
+        vim.keymap.set("v","l","u")
+        vim.keymap.set("v","n","j")
+        vim.keymap.set("v","o","p")
+        vim.keymap.set("v","p","r")
+        vim.keymap.set("v","r","s")
+        vim.keymap.set("v","s","d")
+        vim.keymap.set("v","t","f")
+        vim.keymap.set("v","u","i")
+        vim.keymap.set("v","y","o")
+        vim.keymap.set("v","D","G")
+        vim.keymap.set("v","E","K")
+        vim.keymap.set("v","F","E")
+        vim.keymap.set("v","G","T")
+        vim.keymap.set("v","I","L")
+        vim.keymap.set("v","J","Y")
+        vim.keymap.set("v","K","N")
+        vim.keymap.set("v","L","U")
+        vim.keymap.set("v","N","J")
+        vim.keymap.set("v","O","P")
+        vim.keymap.set("v","P","R")
+        vim.keymap.set("v","R","S")
+        vim.keymap.set("v","S","D")
+        vim.keymap.set("v","T","F")
+        vim.keymap.set("v","U","I")
+        vim.keymap.set("v","Y","O")
+    end
+end
+
+vim.keymap.set("n", "<leader>r", colemak_tog)

env/.config/nvim/spell/en.utf-8.add

@@ -0,0 +1,21 @@
+qpwgraph
+pipewire
+linux
+kde
+wayland
+VR
+ish
+OVR
+ALVR
+picom
+VM
+taskbar
+dwm
+distro
+vesktop
+warframe
+Anthro
+anthro
+optifine
+lol
+cuda