From e966d5328d6f328546db213278d1a1a6cd2f58d5 Mon Sep 17 00:00:00 2001
From: iceyrazor <iceyrazor@mailfence.com>
Date: Sat, 24 May 2025 04:08:28 -0500
Subject: install scripts. reorganization. soon to be deployable

---
 env/.config/nvim/lua/yourmom/cloak.lua  | 293 ++++++++++++++++++++++++++++++++
 env/.config/nvim/lua/yourmom/init.lua   |  50 ++++++
 env/.config/nvim/lua/yourmom/packer.lua |  73 ++++++++
 env/.config/nvim/lua/yourmom/remap.lua  | 262 ++++++++++++++++++++++++++++
 4 files changed, 678 insertions(+)
 create mode 100644 env/.config/nvim/lua/yourmom/cloak.lua
 create mode 100755 env/.config/nvim/lua/yourmom/init.lua
 create mode 100755 env/.config/nvim/lua/yourmom/packer.lua
 create mode 100755 env/.config/nvim/lua/yourmom/remap.lua

(limited to 'env/.config/nvim/lua')

diff --git a/env/.config/nvim/lua/yourmom/cloak.lua b/env/.config/nvim/lua/yourmom/cloak.lua
new file mode 100644
index 0000000..5a13953
--- /dev/null
+++ b/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
diff --git a/env/.config/nvim/lua/yourmom/init.lua b/env/.config/nvim/lua/yourmom/init.lua
new file mode 100755
index 0000000..90e3e6a
--- /dev/null
+++ b/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"
+    }
+})
diff --git a/env/.config/nvim/lua/yourmom/packer.lua b/env/.config/nvim/lua/yourmom/packer.lua
new file mode 100755
index 0000000..6a6e08c
--- /dev/null
+++ b/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)
diff --git a/env/.config/nvim/lua/yourmom/remap.lua b/env/.config/nvim/lua/yourmom/remap.lua
new file mode 100755
index 0000000..1bd421f
--- /dev/null
+++ b/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)
-- 
cgit v1.3