{
  programs.helix = {
    enable = true;
    settings = {
      theme = "my";
      editor = {
        mouse = false;
        trim-trailing-whitespace = true;
        end-of-line-diagnostics = "hint";
        cursor-shape = {
          insert = "bar";
          normal = "block";
          select = "underline";
        };
        indent-guides.enable = true;
        inline-diagnostics.cursor-line = "hint";
        gutters = [ "diagnostics" "spacer" ];
        statusline.right = [ "diagnostics" "register" "position" ];
      };
        };
      };
    };
    themes.my = let
        green = "#07d101";
        blue = "#00bfff";
        cream = "#edf0e0";
        pink = "#f584c6";
        red = "#f85624";
        dustypink = "#d8916e";
        navy = "#0047ab";
        gray = "#c0c0c0";
        greenyellow = "#adff2f";
        electriclime = "#ccff00";
        darkgreen = "#228b22";
        lightpink = "#ffb7c5";
        gold = "#ffd700";
        white = "#ffffff";
        none = "none";
    in rec {
      inherits = "nvim-dark";
      "ui.background" = none;
      type = { fg = blue; modifiers = [ "bold" ]; };
      "type.builtin" = type;
      "type.enum.variant" = { fg = pink; };
      constructor = type;
      constant = pink;
      "constant.builtin" = blue;
      "constant.character" = lightpink;
      "constant.character.escape" = pink;
      "constant.numeric" = gold;
      string = lightpink;
      "string.regexp" = pink;
      "string.special" = { fg = pink; underline.style = "line"; };
      comment = gray;
      variable = electriclime;
      "variable.parameter" = { fg = variable; modifiers = [ "italic" ]; };
      "variable.builtin" = blue;
      "variable.other.member" = { fg = greenyellow; modifiers = [ "bold" ]; };
      label = { fg = green; modifiers = [ "bold" ]; };
      punctuation = cream;
      keyword = { fg = white; modifiers = [ "bold" ]; };
      operator = cream;
      function = gold;
      "function.builtin" = blue;
      namespace = blue;
      special = keyword;
      error = red;
      "markup.header" = variable;
      "markup.header.marker" = keyword;
      "markup.list" = { fg = variable; modifiers = [ "bold" ]; };
      "markup.link.url" = pink;
      "markup.link.text" = variable;
      "markup.link.label" = label;
    };
  };
}
        select = common // { };
      keys = let
        common = {
          g.o = "jump_backward";
          g.O = "jump_forward";
          # toggle gh and gs
          g.h = "goto_first_nonwhitespace";
          g.s = "goto_line_start";
        };
      in {
        normal = common // {
          "C-z" = [ ":write-all" "suspend" ];

- undofile
- g`"
- disable lsp diagnostics in insert mode

  programs.emacs = {
    enable = true;
      })
    ]);
    extraConfig = builtins.readFile ./init.el;
  };
  services.emacs = {
    enable = true;
    client.enable = true;
  };
}
      })
      (epkgs.trivialBuild {
	pname = "myplugins";
	version = "0.0";
	src = ./plugins;
	buildInputs = plugins epkgs;
        # to prevent "Creating directory" "Permission denied" "/homeless-shelter" error
	preBuild = "export HOME=$(pwd)";
    package = pkgs.emacs-nox.pkgs.withPackages (epkgs: plugins epkgs ++ [
      (epkgs.trivialBuild {
	pname = "myconf";
	version = "0.0";
	src = ./lisp;
pkgs: let
  plugins = epkgs: with epkgs; [
    avy
    evil
    evil-surround
    org
    undo-fu-session
    treesit-grammars.with-all-grammars
    nix-ts-mode
    (trivialBuild {
      pname = "elisp-ts-mode";
      version = "0.0";
      src = pkgs.fetchFromGitHub {
        owner = "nverno";
        repo = "emacs-lisp-ts-mode";
        rev = "7d661005a7c4ac8b45d1584c9fdbbd9b1e49eb39";
        hash = "sha256-r2/PVwsPlZ6iPd6vBB7i4AYK0ofwUgRX8I+2FGwjFKI=";
      };
    })
    (trivialBuild {
      pname = "nushell-ts-mode";
      version = "0.0";
      src = pkgs.fetchFromGitHub {
        owner = "herbertjones";
        repo = "nushell-ts-mode";
        rev = "e07ecc59762fab8d5fa35bc6d3f522f74e580a2f";
        hash = "sha256-C4RRph7zaO4PQkZcUSsFg2jWuLcZGtRjaPcNICj3JG0=";
      };
    })
    (trivialBuild {
      pname = "zig-ts-mode";
      version = "0.0";
      src = pkgs.fetchFromGitHub {
        owner = "emacsmirror";
        repo = "zig-ts-mode";
        rev = "bb1e8287800868ee338e986bda5b5a1f5abf7445";
        hash = "sha256-vstl13IWwAxaQTsy/bn/uCet4Oxm2edKjmwREfhNAk8=";
      };
    })
  ];
in {

(setq wl-copy-process nil)
(defun wl-copy (text)
  (setq wl-copy-process (make-process :name "wl-copy"
  				      :buffer nil
				      :command '("wl-copy" "-f" "-n")
				      :connection-type 'pipe
				      :noquery t))
  (process-send-string wl-copy-process text)
  (process-send-eof wl-copy-process))
(defun wl-paste ()
  (if (and wl-copy-process (process-live-p wl-copy-process))
      nil
      (shell-command-to-string "wl-paste -n | tr -d \r")))
(setq interprogram-cut-function #'wl-copy
      interprogram-paste-function #'wl-paste)
(provide 'clipboard)

(require 'gc)
(require 'clipboard)
(require 'opt)
(require 'face)
(require 'hooks)
(provide 'conf)

(let ((green "#07d101")
      (blue "#00bfff")
      (cream "#edf0e0")
      (pink "#f584c6")
      (red "#f85624")
      (dustypink "#d8916e")
      (navy "#0047ab")
      (gray "#c0c0c0")
      (greenyellow "#adff2f")
      (electriclime "#ccff00")
      (darkgreen "#228b22")
      (lightpink "#ffb7c5")
      (gold "#ffd700"))
  (set-face-attribute 'default nil :background "none")
  (set-face-attribute 'region nil :background blue)
  (set-face-attribute 'font-lock-comment-face nil :foreground gray)
  (set-face-attribute 'font-lock-constant-face nil :foreground pink)
  (set-face-attribute 'font-lock-string-face nil :foreground lightpink)
  (set-face-attribute 'font-lock-number-face nil :foreground gold)
  (set-face-attribute 'font-lock-variable-name-face nil :foreground greenyellow :weight 'bold)
  (set-face-attribute 'font-lock-function-name-face nil :foreground gold)
  (set-face-attribute 'font-lock-keyword-face nil :foreground green)
  (set-face-attribute 'font-lock-operator-face nil :foreground cream)
  (set-face-attribute 'font-lock-preprocessor-face nil :foreground dustypink)
  (set-face-attribute 'font-lock-type-face nil :foreground blue)
  (set-face-attribute 'escape-glyph nil :foreground pink)
  (set-face-attribute 'font-lock-warning-face nil :foreground navy :background cream :weight 'bold)
  (set-face-attribute 'isearch nil :foreground cream)
  )
(provide 'face)

(setq gc-cons-threshold (* 1024 1024 128))
(run-with-idle-timer 5 nil #'garbage-collect)
(provide 'gc)

(add-hook 'before-save-hook #'delete-trailing-whitespace)
(provide 'hooks)

(setq indent-tabs-mode nil
      auto-save-default nil
      create-lockfiles nil
      select-enable-clipboard nil
      )
(setq-default mode-line-format nil)
(menu-bar-mode -1)
(tooltip-mode -1)
(prefer-coding-system 'utf-8)
(global-auto-revert-mode 1)
(provide 'opt)
(save-place-mode 1)
      make-backup-files nil

(require 'conf)
(require 'plugins)
(require 'profiler)
(profiler-start 'cpu)

(require 'evil)
(require 'avy)
(require 'eglot)
(require 'xref)
(require 'flymake)
(defmacro toggle-mode (mode)
  `(if ,mode (,mode -1) (,mode 1)))
(defun toggle-eglot-inlay-hints-mode () (toggle-mode eglot-inlay-hints-mode))
(evil-mode 1)
(define-key evil-normal-state-map (kbd "gw") #'avy-goto-word-0)
(define-key evil-normal-state-map (kbd "gl") #'evil-end-of-line)
(define-key evil-normal-state-map (kbd "gh") #'evil-first-non-blank)
(define-key evil-normal-state-map (kbd "gd") #'xref-find-definitions)
(define-key evil-normal-state-map (kbd "gR") #'xref-find-references)
(define-key evil-normal-state-map (kbd "gra") #'eglot-code-actions)
(define-key evil-normal-state-map (kbd "grh") #'eldoc)
(define-key evil-normal-state-map (kbd "grn") #'eglot-rename)
(define-key evil-normal-state-map (kbd "]d") #'flymake-goto-next-error)
(define-key evil-normal-state-map (kbd "[d") #'flymake-goto-prev-error)
(define-key evil-normal-state-map (kbd "^ h") #'toggle-eglot-inlay-hints-mode)
(define-key evil-normal-state-map "Q" #'evil-save-modified-and-close)
(define-key evil-normal-state-map "=" #'eglot-format)
(define-key evil-visual-state-map "v" #'evil-visual-block)
(provide 'binds)

(require 'eglot)
(add-to-list 'eglot-server-programs '((nix-ts-mode) . ("nixd")))
(add-to-list 'eglot-server-programs '((nushell-ts-mode) . ("nu" "--lsp")))
(add-hook 'c-ts-mode-hook #'eglot-ensure)
(add-hook 'nix-ts-mode-hook #'eglot-ensure)
(add-hook 'zig-ts-mode-hook #'eglot-ensure)
(provide 'lsp)

(setq evil-move-cursor-back nil
      evil-shift-width 2
      evil-want-change-word-to-end nil
      evil-want-C-u-scroll t
      evil-want-C-w-delete nil
      evil-search-module 'evil-search
      evil-ex-visual-char-range t
      evil-ex-complete-emacs-commands t
      evil-normal-state-cursor '(box "darkolivegreen")
      evil-insert-state-cursor '((bar . 2) "darkolivegreen")
      evil-undo-system 'undo-redo
      )
(require 'undo-fu-session)
(undo-fu-session-global-mode)
(provide 'opt)

(require 'opt)
(require 'binds)
(require 'lsp)
(require 'ts)
(provide 'plugins)

(when (fboundp 'treesit-available-p)
  (setq major-mode-remap-alist
        '((c-mode . c-ts-mode)
	  (emacs-lisp-mode . emacs-lisp-ts-mode)
          )))
(add-to-list 'auto-mode-alist '("\\.nix\\'" . nix-ts-mode))
(require 'emacs-lisp-ts-mode)
(require 'nix-ts-mode)
; (require 'nushell-ts-mode)
(require 'zig-ts-mode)
(provide 'ts)

AlignAfterOpenBracket: BlockIndent
AlignArrayOfStructures: Right
AlignConsecutiveAssignments: false
AlignConsecutiveMacros: true
AlignConsecutiveShortCaseStatements:
  Enabled: true
AlignConsecutiveTableGenCondOperatorColons: true
AlignEscapedNewlines: DontAlign
AlignOperands: AlignAfterOperator
AlignTrailingComments:
  Kind: Always
  OverEmptyLines: 1
AllowShortBlocksOnASingleLine: Always
AllowShortCaseExpressionOnASingleLine: true
AllowShortCaseLabelsOnASingleLine: false
AllowShortCompoundRequirementOnASingleLine: true
AllowShortEnumsOnASingleLine: true
AllowShortFunctionsOnASingleLine: None
AllowShortIfStatementsOnASingleLine: AllIfsAndElse
AllowShortLoopsOnASingleLine: true
AlwaysBreakBeforeMultilineStrings: false
BinPackArguments: false
# BinPackLongBracedList: true
BraceWrapping:
  AfterCaseLabel: false
  AfterClass: true
  AfterEnum: false
  AfterFunction: false
  AfterNamespace: true
  AfterStruct: false
  AfterUnion: false
  AfterExternBlock: true
  BeforeElse: false
  BeforeWhile: false
  # BraceWrappingAfterControlStatementStyle: Never
  IndentBraces: false
BreakAdjacentStringLiterals: false
BreakAfterAttributes: Leave
BreakAfterJavaFieldAnnotations: true
BreakAfterReturnType: Automatic
BreakBeforeBinaryOperators: All
BreakBeforeBraces: Attach
BreakBeforeInlineASMColon: OnlyMultiline
BreakBeforeTernaryOperators: true
BreakFunctionDefinitionParameters: false
BreakStringLiterals: true
# ColumnLimit: 80
ContinuationIndentWidth: 2
ForEachMacros: [test, bench]
IncludeBlocks: Merge
IndentCaseBlocks: false
IndentCaseLabels: false
IndentGotoLabels: false
IndentPPDirectives: BeforeHash
IndentWidth: 2
IndentWrappedFunctionNames: false
InsertNewlineAtEOF: true
IntegerLiteralSeparator:
  Binary: 0
  Decimal: 3
  DecimalMinDigits: 5
  Hex: 2
  HexMinDigits: 5
KeepEmptyLines:
  AtEndOfFile: false
  AtStartOfBlock: false
  AtStartOfFile: false
LineEnding: LF
MaxEmptyLinesToKeep: 1
PPIndentWidth: 1
PointerAlignment: Right
QualifierAlignment: Right
# ReflowComments: Never
RemoveBracesLLVM: false
# RemoveEmptyLinesInUnwrappedLines: true
RemoveParentheses: Leave
RemoveSemicolon: false
SortIncludes: CaseSensitive
SpaceAfterCStyleCast: false
SpaceAfterLogicalNot: false
SpaceAroundPointerQualifiers: After
SpaceBeforeAssignmentOperators: true
SpaceBeforeCaseColon: false
SpaceBeforeCpp11BracedList: false
SpaceBeforeParens: ControlStatements
SpaceBeforeSquareBrackets: false
SpaceInEmptyBlock: true
SpacesBeforeTrailingComments: 1
SpacesInContainerLiterals: true
SpacesInLineCommentPrefix:
  Minimum: 1
  Maximum: -1
# SpaceInParens: Never
SpacesInSquareBrackets: false
StatementMacros: [test_table]
TabWidth: 2
# UseTab: Never

.gitignore
.gptignore
plugins/*
.git/*
*.json
README.md
**/*.so
**/.cache/*
archive/*

{
	"$schema": "https://raw.githubusercontent.com/LuaLS/vscode-lua/master/setting/schema.json",
	"runtime": {
		"version": "LuaJIT"
	},
	"workspace": {
		"library": [
			"runtime/lua",
			"${3rd}/busted/library",
			"${3rd}/luv/library"
	],
	"ignoreDir": [
		"test"
	],
	"checkThirdParty": "Disable"
	},
	"diagnostics": {
		"globals": ["vim"],
		"hint.enable": false,
		"disable": [
			"luadoc-miss-see-name"
		]
	}
}

}
  xdg.configFile."nvim/init.lua".source = ./init.lua;
  xdg.configFile."nvim/lua".source = ./lua;
pkgs: let
  inherit (builtins) readDir;
  inherit (pkgs.lib) filterAttrs mapAttrsToList hasSuffix;
  fnls = d: readDir d |> filterAttrs (k: v: v == "regular" && hasSuffix ".fnl" k) |> mapAttrsToList (k: _: "${d}/${k}");
  compile = input: /* bash */ ''
    fennel --require-as-include -c --add-fennel-path ${./.}/?.fnl ${input} > $out/${input} # output path
  '';
in {
  programs.neovim = {
    enable = true;
    viAlias = true;
    vimAlias = true;
    defaultEditor = true;
  };
  };
  programs.neovide = {
    settings = {
      font = {
        normal = [{family =  "PlemolJP35 Console NF"; }];
        size = 8;
      };
    };
    # too heavy to build
    enable = false;

-- overwrite superfluous paths
vim.opt.runtimepath = '~/.config/nvim,~/.local/share/nvim/runtime,~/.local/lib/nvim'
local clibpath = vim.fn.stdpath('config') .. '/lib/?.so'
package.cpath = package.cpath .. ';' .. clibpath
require 'autocmd'
require 'dmacro'
require 'fcitx5'
require 'ftplugin'
require 'gitlens'
require 'opt'
require 'plugin'
require 'colorscheme'
require 'ui'

local au = vim.api.nvim_create_autocmd
local map = vim.keymap.set
function Treesitter_config()
	local prefix = vim.env.HOME .. '/.local/share/nvim/runtime/queries/'
	if #vim.o.filetype > 0 and vim.uv.fs_stat(prefix .. vim.o.filetype) then
		vim.treesitter.start()
	end
end
au({ 'VimEnter' }, {
    callback = function()
        local session = vim.env.HOME .. '/.cache/nvim/session.vim'
        if vim.uv.fs_stat(session) then
            vim.cmd.source(session)
            vim.fs.rm(session)
        end
    end
})
au({ 'UIEnter' }, {
	callback = function()
		require 'map'
        vim.cmd.rshada()
            vim.cmd.term('nu')
        else
            vim.cmd.normal 'g`"'
        end
	end
})
au({ 'FileType' }, {
	callback = Treesitter_config
})
au({ 'CmdLineEnter' }, {
	callback = function()
		require 'cdtrack'
	end,
    once = true
})
au({ 'TextYankPost' }, {
	callback = function()
		if vim.v.event.regname == '' then
			vim.fn.setreg(vim.v.event.operator, vim.fn.getreg())
		end
	end
})
au({ 'CmdWinEnter' }, {
	callback = function()
		map('n', '<ESC>', '<cmd>q!<CR>', { buffer = true })
		vim.bo.filetype = 'vim'
	end
})
au({ 'BufWinEnter' }, {
	pattern = 'COMMIT_EDITMSG',
	callback = function()
		for i, s in ipairs(vim.fn.systemlist('git diff --cached')) do
			vim.fn.append(i - 1, '# ' .. s)
		end
	end
})
au({ 'BufWritePre' }, {
	callback = function()
		local dir = vim.fn.expand('<afile>:p:h')
		local f = io.open(dir, 'r')
		if f then
			f:close()
			return
		end
		vim.fn.mkdir(dir, 'p')
	end
})
au({ 'VimLeave' }, { command = 'wshada' })
        if vim.fn.argc() == 0 and vim.g.neovide then

	green = '#07d101',
	blue = '#00bfff',
	cream = '#edf0e0',
	red = '#f85624',
	navy = '#0047ab',
	gray = '#c0c0c0',
	greenyellow = '#adff2f',
	electriclime = '#ccff00',
	gold = '#ffd700',
}
---@param group string
---@param opts table
local function hi(group, opts)
	vim.api.nvim_set_hl(0, group, opts)
end
hi('Normal', { bg = 'None' })
hi('NormalNC', { bg = 'None' })
hi('SignColumn', { bg = 'None' })
hi('CursorLine', { bg = 'none' })
hi('CursorLineNC', { bg = 'none' })
hi('StatusLine', { bg = 'none' })
hi('StatusLineNC', { bg = 'none' })
hi('LspInlayHint', { fg = 'DarkCyan' })
hi('@variable.parameter', { italic = true })
hi('@variable', { fg = ns.electriclime })
hi('Boolean', { fg = ns.blue })
hi('Comment', { fg = ns.gray })
hi('Constant', { fg = ns.pink })
hi('Statement', { fg = ns.green, bold = true })
hi('KeyWord', { fg = ns.cream, bold = true })
hi('PreProc', { fg = ns.dustypink })
hi('Identifier', { fg = ns.greenyellow, bold = true })
hi('Special', { fg = ns.blue })
hi('String', { fg = ns.lightpink })
hi('Type', { fg = ns.blue, bold = true })
hi('Number', { fg = ns.gold })
hi('Todo', { fg = ns.navy, bg = ns.cream, bold = true })
hi('Operator', { fg = ns.cream })
hi('Function', { fg = ns.gold })
hi('SpecialChar', { fg = ns.pink })
hi('Delimiter', { fg = ns.cream })
hi('Visual', { bg = ns.blue })
hi('PmenuSel', { fg = ns.gold, bg = ns.blue })
hi('Search', { fg = ns.cream })
hi('CurSearch', { fg = ns.darkgreen, bg = ns.cream })
hi('Substitute', { fg = ns.cream })
hi('WinSeparator', { fg = ns.blue })
hi('LineNr', { fg = ns.navy, bg = 'none' })
hi('CursorLineNR', { fg = ns.red, bg = 'none', bold = true })
	darkgreen = '#228b22',
	lightpink = '#ffb7c5',
	dustypink = '#d8916e',
	pink = '#f584c6',
local ns = {

local command = vim.api.nvim_create_user_command
command('M', function(opts)
	local args = table.concat(opts.fargs, ' ')
	vim.cmd.term('man ' .. args .. '| bat -p -l man')
	vim.cmd.startinsert()
end, {
	nargs = '*',
	bar = true,
})
command('W', function(opts)
	vim.cmd.term('w3m ' .. opts.fargs[1])
	vim.cmd.startinsert()
end, {
	nargs = 1,
	bar = true
})
command('H', function(opts)
	vim.cmd('tab h ' .. opts.fargs[1])
	require 'wrapwin'.open_wrapwin()
end, {
	nargs = 1,
	complete = 'help'
})
command('VS', function(_)
	require 'wrapwin'.open_wrapwin()
end, {
	nargs = 0,
})

local dmacro_key = '<C-T>'
local clear_key = '<C-S-T>'
local key_log = ''
local prev_macro = nil
---@param kl string
---@return string
local function guess_macro(kl)
	for i = #kl / 2, #kl do
		local curspan = kl:sub(i)
		local srchspan = kl:sub(1, i - 1)
		local start, fin = srchspan:find(curspan, 1, true)
		if start and fin then
			prev_macro = srchspan:sub(start)
			return srchspan:sub(fin + 1)
		end
	end
	return ''
end
---@param typed string
local function key_logger(_, typed)
	local readable_keycode = vim.fn.keytrans(typed)
	if readable_keycode == dmacro_key then return end
	key_log = key_log .. readable_keycode
	if #key_log > 100 then
		key_log = key_log:sub(#key_log - 100)
	end
	prev_macro = nil
end
vim.on_key(key_logger)
vim.keymap.set({ 'i', 'n', 'v', 'o', 'c', 't' }, dmacro_key, function()
	vim.api.nvim_input(prev_macro or guess_macro(key_log))
end)
vim.keymap.set({ 'i', 'n', 'v', 'o', 'c', 't' }, clear_key, function()
	key_log = ''
end)

local IM_cmd = 'fcitx5-remote'
local toggle_IM = { IM_cmd, '-t' }
local was_IM_enabled = false -- was im enabled in previous insert mode
---@return boolean
local function get_IM_status()
	return vim.system({ IM_cmd }):wait().stdout:sub(1, 1) == '2'
end
local function toggle_IM_status()
	if was_IM_enabled then vim.system(toggle_IM) end
end
vim.api.nvim_create_autocmd('InsertEnter', { callback = toggle_IM_status })
vim.api.nvim_create_autocmd('InsertLeave', {
	callback = function()
		was_IM_enabled = get_IM_status()
		toggle_IM_status()
	end
})

return {
	lsp = {
		name = 'asm-lsp',
		cmd = { 'asm-lsp' }
	}
}

return {
	lsp = {
		name = 'clangd',
		cmd = { 'clangd' }
	},
	quickeval_cmd = 'clang-repl --summary-file=',
	snippet = {
		{ abbr = 'in',   snip = '#include <$1.h>\n$0' },
		{ abbr = 'i',    snip = 'if ($1) {\n  $2\n}\n$0' },
		{ abbr = 'f',    snip = 'for ($1; $2; $3) {\n  $4\n}\n$0' },
		{ abbr = 's',    snip = 'switch ($1) {\n  $2\n}\n$0' },
		{ abbr = 'c',    snip = 'case $1:\n  $0' },
		{ abbr = 'w',    snip = 'while ($1) {\n  $2\n}\n$0' },
		{ abbr = 'd',    snip = '#define $0' },
		{ abbr = 'p',    snip = 'printf("$1", $2);\n$0' },
		{ abbr = 'call', snip = '$1($2);\n$0' },
	},
	callback = function()
		vim.bo.expandtab = true
		vim.bo.shiftwidth = 2
		vim.bo.tabstop = 2
		vim.cmd 'iabbrev and &&'
		vim.cmd 'iabbrev or \\|\\|'
		vim.cmd 'iabbrev not !'
	end
}

return {
	lsp = {
		name = 'cmake-ls',
		cmd = { 'cmake-language-server' }
	}
}

return require 'ftplugin.c'

return {
	lsp = {
		name = 'fish-lsp',
		cmd = { 'fish-lsp', 'start' }
	}
}

return {
	lsp = {
		name = 'gopls',
		cmd = { 'gopls' }
	}
}

return {
    lsp = {
        name = 'haskell',
        cmd = { 'haskell-language-server-wrapper' }
    }
}

return {
    lsp = {
        name = 'java-language-server',
        cmd = { 'java-language-server' }
    }
}

return {
	lsp = {
		name = 'lua-ls',
		cmd = { 'lua-language-server' },
		root_dir = vim.fn.stdpath('config')
	},
	snippet = {
		{ abbr = 'i', snip = 'if $1 then\n\t$2\nend\n$0' },
		{ abbr = 'f', snip = 'for $1 in $2 do\n\t$3\nend\n$0' },
		{ abbr = 'fn', snip = 'function $1($2)\n\t$3\nend\n$0' },
		{ abbr = 'l', snip = 'function($1)\n\t$2\nend\n$0' },
	}
}

return {
	quickeval_cmd = 'make -n -f ',
	snippet = {
		{ abbr = 'target', snip = '$1: $2\n\t$0' },
		{ abbr = 'p', snip = '.PHONY: $1' },
	}
}

return {
    lsp = {
        name = 'nixd',
        cmd = { 'nixd' }
    }
}

return {
	lsp = {
		name = 'nu',
		cmd = { 'nu', '--lsp' }
	}
}

return {
	lsp = {
		name = 'rust-analyzer',
		cmd = { 'rust-analyzer' }
	},
	snippet = {
		{ abbr = 'i', snip = 'if $1 {\n\t$2\n}\n$0' },
		{ abbr = 'f', snip = 'for $1 in $2 {\n\t$3\n}\n$0' },
		{ abbr = 'w', snip = 'while $1 {\n\t$2\n}\n$0' },
		{ abbr = 'm', snip = 'match $1 {\n\t$2\n}\n$0' },
		{ abbr = 'p', snip = '$1 => $2,\n$0' },
		{ abbr = 'fn', snip = 'fn $1($2) {\n\t$3\n}\n$0' },
		{ abbr = 'fnr', snip = 'fn $1($2) -> $3 {\n\t$4\n}\n$0' },
	}
}

return {
	quickeval_cmd = 'scheme',
	snippet = {
		{ abbr = 'i', snip = '(if ${1:cond}\n  ${2:true}\n  ${3:false})' },
		{ abbr = 'fn', snip = '(define $1 (lambda ($2)\n  $3))' },
	},
	callback = function()
		vim.bo.expandtab = true
		vim.bo.shiftwidth = 2
		vim.bo.tabstop = 2
	end
}

return {
	lsp = {
		name = 'texlab',
		cmd = { 'texlab' }
	},
	snippet = {
		{
			abbr = '!',
			snip = [[\\documentclass[uplatex, dvipdfmx, a4paper]{ltjsarticle}
\\usepackage{}
\\title{$1}
\\author{$2}
\\date{}
\\begin{document}
\\maketitle
\\newpage
$0
\\end{document}]]
		},
		{ abbr = 'b', snip = '\\\\begin{${1:env}}\n$2\n\\\\end{${1:env}}\n$0' },
		{ abbr = 's', snip = '\\\\section{$1}\n$0' },
		{ abbr = 'sb', snip = '\\\\subsection{$1}\n$0' },
	}
}

return {
	lsp = {
		name = 'tinymist',
		cmd = { 'tinymist' }
	}
}

return {
	lsp = {
		name = 'yaml-ls',
		cmd = { 'yaml-language-server' }
	}
}

return {
	lsp = {
		name = 'zls-prime',
		cmd = { 'zls-prime' }
	},
	snippet = {
		{ abbr = 'i', snip = 'if ($1) {\n    $2\n}\n$0' },
		{ abbr = 'f', snip = 'for ($1) |$2| {\n    $3\n}\n$0' },
		{ abbr = 'w', snip = 'while ($1) {\n    $2\n}\n$0' },
		{ abbr = 'fn', snip = 'fn $1($2) $3 {\n    $4\n}\n$0' },
		{ abbr = 's', snip = 'switch ($1) {\n    $2\n}\n$0' },
		{ abbr = 'p', snip = '$1 => $2,\n$0' },
		{ abbr = 't', snip = 'test "$1" {\n    $2\n}' },
	},
	callback = function()
		vim.bo.expandtab = true
		vim.bo.shiftwidth = 4
		vim.bo.tabstop = 4
	end
}

return {
    lsp = {
        name = "fennel-ls",
        cmd = { "fennel-ls" }
    }
}

local au = vim.api.nvim_create_autocmd
local snip = require 'snippet'
--- evaluate code selected in visual mode
---@param cmd string[]
local function quickeval(cmd)
	local range = require 'utils'.get_visual_selection()
	local tmpfilename = '/tmp/nvim-ftplugin.' .. vim.fn.expand('%:e')
	local file = assert(io.open(tmpfilename, 'w'))
	for _, line in ipairs(content) do
		file:write(line .. '\n')
	end
	file:close()
	vim.cmd('vert term ' .. cmd .. tmpfilename)
	vim.cmd.startinsert()
end
au('FileType', {
	callback = function(ev)
		local ft = ev.match
		local ok, ftp = pcall(require, 'ftplugin.' .. ft)
		if not ok then return end
		if ftp.lsp then
			ftp.lsp.on_attach = require 'lsp'.on_attach
				vim.lsp.start(ftp.lsp)
			end)):send()
		end
		if ftp.quickeval_cmd then
			vim.keymap.set('v', 'x', function()
				quickeval(ftp.quickeval_cmd)
			end)
		end
		if ftp.callback then
			ftp.callback()
		end
		if ftp.snippet then
			snip.setup_keymap()
			for _, sn in ipairs(ftp.snippet) do
				snip.set_snip(sn)
			end
		end
	end
})
			vim.uv.new_async(vim.schedule_wrap(function()
    local content = vim.fn.getregion(start, end_, { type = vim.fn.mode(1) })
	local start = range.start
	local end_ = range.end_

---@param directory string
---@param files table
---@return table
local function get_files_recursive(directory, files)
	local curdir = vim.env.PWD
	local directory_files = vim.fn.readdir(directory)
	local ignored_dirs = { '.', '..', '.git', 'build', 'bin', 'plugins' }
	for _, file in ipairs(directory_files) do
		local full_path = directory .. '/' .. file
		if vim.fn.isdirectory(full_path) ~= 0 and not vim.tbl_contains(ignored_dirs, file) then
			get_files_recursive(full_path, files)
		else
			table.insert(files, full_path:sub(#curdir + 2))
		end
	end
	return files
end
local file_cache = nil
vim.api.nvim_create_user_command('F',
	function(opts)
		vim.cmd.tabnew(opts.fargs[1])
	end,
	{
		nargs = 1,
		bar = true,
		complete = function(trigger)
			if not file_cache then
				file_cache = get_files_recursive(vim.env.PWD, {})
			end
			if #trigger > 0 then
				return vim.fn.matchfuzzy(file_cache, trigger)
			else
				return file_cache
			end
		end
	})

local map = vim.keymap.set
local api = vim.api
local function printBlameText()
	local currFile = vim.fn.expand('%')
	local line = api.nvim_win_get_cursor(0)
	local blame = vim.fn.system(string.format('git blame -c -L %d,%d %s', line[1], line[1], currFile))
    local hash = string.match(blame, '%S+')
	if hash == '00000000' then
		Text = 'Not Committed Yet'
	else
		local cmd = 'git show ' .. hash .. " --format='%an | %ar | %s' | head -n 1"
		Text = vim.fn.system(cmd):sub(1, -2)
		if Text:find('fatal') then
			Text = 'Not Committed Yet'
		end
	end
	print(Text)
end
map('n', '\\b', printBlameText)

M = {}
vim.keymap.set('n', '=', vim.lsp.buf.format)
vim.keymap.set('n', '^h', function()
	vim.lsp.inlay_hint.enable(not vim.lsp.inlay_hint.is_enabled())
end)
vim.keymap.set('n', 'gd', vim.lsp.buf.definition)
vim.keymap.set('n', 'grh', vim.lsp.buf.hover)
vim.diagnostic.config({ virtual_text = true })
vim.lsp.document_color.enable(true, 0, { style = 'virtual' })
function M.on_attach(client, bufnr)
    local chars = {}
    for i = 32, 126 do table.insert(chars, string.char(i)) end
    client.server_capabilities.completionProvider.triggerCharacters = chars
	vim.lsp.completion.enable(true, client.id, bufnr, {
		autotrigger = true,
		convert = function(item)
			return { abbr = item.label:gsub('%b()', '') }
		end
	})
end
return M

local map = vim.keymap.set
local submode = require 'submode'
vim.g.mapleader = ' '
local function smart_gf()
	local fpath = vim.fn.expand('<cfile>')
	if fpath:sub(1, 8) == 'https://' then
		vim.cmd.term('w3m ' .. fpath)
		vim.cmd.startinsert()
	else
		vim.cmd.normal 'gF'
	end
end
-- consider indentation
local function smart_i()
	if vim.fn.getline('.'):match('^ *$') then
		vim.api.nvim_input '"_cc'
	else
		-- vim.api.nvim_input 'i' -- freeze
		vim.cmd.startinsert()
	end
end
map('n', '<BS>', '<C-b>')
map('n', '<Delete>', '<C-f>')
map('n', '<C-S-e>', '5<C-e>')
map('n', '<C-S-y>', '5<C-y>')
map('n', 'i', smart_i)
map('n', 'S', 'c^')
map('n', 'Q', 'ZZ', { noremap = true })
map('n', 'ZZ', function()
    vim.cmd.mksession(vim.env.HOME .. '/.cache/nvim/session.vim')
    vim.cmd.wqa()
end)
map('n', 'G', '')
map('n', 'GG', 'G')
map('n', 'gk', '25k')
map('n', 'gj', '25j')
map('n', 'gf', smart_gf)
map('n', 'gb', vim.cmd.bnext)
map('n', 'gB', vim.cmd.bprev)
map('n', '^n', function() vim.o.number = not vim.o.number end)
map('n', '^r', function() vim.o.relativenumber = not vim.o.relativenumber end)
map('n', '^s', function() vim.o.spell = not vim.o.spell end)
map('n', '<C-z>', ':w<CR><C-z>')
map('n', 'zS', vim.show_pos)
map({ 'n', 'v' }, 'q;', 'q:')
map({ 'n', 'o', 'v' }, 'K', '5k')
map({ 'n', 'o', 'v' }, 'J', '5j')
map({ 'n', 'v' }, 'x', '"_d')
map({ 'n', 'v' }, 'X', '"_D')
map({ 'n', 'v' }, ']]', '<C-]>')
map({ 'n', 'v' }, '<Leader>y', [["+y]])
map({ 'n', 'v' }, '<Leader>Y', [["+Y]])
map({ 'n', 'v' }, '<Leader>d', [["_d]])
map({ 'n', 'v', 'o' }, 'gl', '$l')
map({ 'n', 'v', 'o' }, 'gh', '^')
map({ 'n', 'v', 'o' }, ']b', '])')
map({ 'n', 'v', 'o' }, '[b', '[(')
map({ 'n', 'v', 'o' }, ']B', ']}')
map({ 'n', 'v', 'o' }, '[B', '[{')
map('i', '<Esc>', '<Right><Esc>')
map('v', '<C-k>', ":m '<-2<CR>gv=gv")
map('v', '<C-j>', ":m '>+1<CR>gv=gv")
map('v', 'v', '<C-v>')
map('v', 'aa', 'VggoG')
map('o', '.', 'i>')
map('o', 'iq', "i'")
map('o', 'iQ', 'i"')
map('o', 'aq', "a'")
map('o', 'aQ', 'a"')
map('o', 'i<Space>', 'iW')
map('o', 'a<Space>', 'aW')
map('t', '<C-\\>', '<C-\\><C-n>')
submode.set_submode_keymap('n', 'g', {
	{ key = 't' },
	{ key = 'T' },
	{ key = 'e' },
	{ key = 'E' },
	{ key = 'J' },
})
submode.set_submode_keymap('n', 'd', {
	{ key = 'h' },
	{ key = 'l' },
})
submode.set_submode_keymap('n', '<C-w>', {
	{ key = '>' },
	{ key = '<' },
	{ key = '+' },
	{ key = '-' },
	{ key = 'h' },
	{ key = 'j' },
	{ key = 'k' },
	{ key = 'l' },
})
submode.set_submode_keymap('n', 'z', {
	{ key = '<Space>', run_when = { entering = '<C-f>', repeating = '<C-f>' } },
	{ key = 'b',       run_when = { entering = '<C-b>', repeating = '<C-b>' } },
})
-- When pressed once, it does not move, but registers the word at the cursor position in the / register.
submode.set_submode_keymap('n', '*', {
	{ key = '*', run_when = { entering = '#*', repeating = '*' } },
})
submode.set_submode_keymap('n', '#', {
	{ key = '#', run_when = { entering = '*#', repeating = '#' } },
})
submode.acceleration_key('n', 'j')
submode.acceleration_key('n', 'k')
submode.acceleration_key('n', 'h')
submode.acceleration_key('n', 'l')
local function safe_cabbrev(lhs, rhs)
	vim.cmd('cabbrev <expr> ' ..
		lhs .. ' (getcmdtype() ==# ":" && getcmdline() ==# "' .. lhs .. '") ? "' .. rhs .. '" : "' .. lhs .. '"')
end
safe_cabbrev('r', 'lua require')
safe_cabbrev('l', 'lua')
vim.cmd 'cabbrev api vim.api'

local o = vim.opt
o.autoread = true
o.autowrite = true
o.complete = 'w,i,d,kspell'
o.completeopt = 'menuone,preinsert,noselect,popup,fuzzy'
o.cursorline = true
o.expandtab = true
o.foldmethod = 'manual'
o.fillchars = { stl = ' ', stlnc = ' ' }
o.gdefault = true
o.guicursor = 'n-v-c-sm:block,i-ci-ve:ver25-blinkwait1000-blinkoff300-blinkon1000,t:block-TermCursor'
o.hidden = true
o.ignorecase = true
o.hlsearch = false
o.incsearch = false
o.laststatus = 0
o.mouse = ''
o.number = false
o.paragraphs = ''
o.path = '.,,,**'
o.ruler = false
o.scrolloff = 10
o.shada = ''
o.shell = '/run/current-system/sw/bin/zsh'
o.shiftwidth = 4
o.showcmd = false
o.showmode = false
o.showtabline = 0
o.signcolumn = 'yes'
o.smartcase = true
o.smartindent = true
o.statusline = ' '
o.tabstop = 4
o.termguicolors = true
o.textwidth = 0
o.timeout = false
o.undodir = vim.fn.stdpath('data') .. '/undo'
o.undofile = true
o.wildmenu = true
o.wrap = false
vim.g.copilot_filetypes = { gitcommit = true, yaml = true, markdown = true }
if vim.g.neovide then
	vim.g.neovide_hide_mouse_when_typing = true
	vim.g.neovide_opacity = 1.0
	vim.g.transparency = 1.0
	vim.g.neovide_text_gamma = 0
	vim.g.neovide_text_contrast = 0.0
	vim.g.terminal_color_0  = '#171717' -- black
	vim.g.terminal_color_1  = '#d81765' -- normal red
	vim.g.terminal_color_2  = '#97d01a' -- normal green
	vim.g.terminal_color_3  = '#ffa800' -- normal yellow
	vim.g.terminal_color_4  = '#16b1fb' -- normal blue
	vim.g.terminal_color_5  = '#ff2491' -- normal magenta
	vim.g.terminal_color_6  = '#0fdcb6' -- normal cyan
	vim.g.terminal_color_7  = '#ebebeb' -- light gray
	vim.g.terminal_color_8  = '#88757c' -- dark gray
	vim.g.terminal_color_9  = '#ff0000' -- bright red
	vim.g.terminal_color_10 = '#76b639' -- bright green
	vim.g.terminal_color_11 = '#f7b125' -- bright yellow
	vim.g.terminal_color_12 = '#289cd5' -- bright blue
	vim.g.terminal_color_13 = '#ff2491' -- bright magenta
	vim.g.terminal_color_14 = '#0a9b81' -- bright cyan
	vim.g.terminal_color_15 = '#f8f8f8' -- white
end

local au = vim.api.nvim_create_autocmd
local map = vim.keymap.set
local pluginOptions = require 'plugindata'
---@param plugname string
function Load_plugin(plugname)
	if pluginOptions[plugname] then
		local opts = pluginOptions[plugname].opts
		local callback = pluginOptions[plugname].callback
		local dependencies = pluginOptions[plugname].dependencies
		if dependencies then
			for _, dep in ipairs(dependencies) do
				Load_plugin(dep)
			end
		end
		if opts and modname then require(modname).setup(opts) end
		if callback then callback() end
		pluginOptions[plugname] = nil
	end
end
au({ 'UIEnter' }, {
	callback = function()
		Load_plugin 'folke/flash.nvim'
		Load_plugin 'gbprod/substitute.nvim'
		Load_plugin 'kylechui/nvim-surround'
		Load_plugin 'andersevenrud/nvim_context_vt'
	end
})
map('n', '^a', function()
	Load_plugin 'zbirenbaum/copilot.lua'
	local sug = require 'copilot.suggestion'
	map('n', '^a', sug.toggle_auto_trigger)
	sug.toggle_auto_trigger()
end)
map('n', 'g/', function()
	Load_plugin 'nvim-telescope/telescope.nvim'
	local tb = require 'telescope.builtin'
	map('n', 'g/', tb.live_grep)
	tb.live_grep()
end)
map('n', 'm', function()
	Load_plugin 'niuiic/track.nvim'
	vim.keymap.del('n', 'm')
	vim.fn.feedkeys 'm'
end)
map('n', '<A-n>', function()
	Load_plugin 'SmiteshP/nvim-navbuddy'
	map('n', '<A-n>', vim.cmd.Navbuddy)
	vim.cmd.Navbuddy()
end)
au({ 'InsertEnter', 'CmdlineEnter' }, {
	once = true,
	callback = function()
	end
})
au({ 'CursorMoved' }, {
	once = true,
	callback = function()
		Load_plugin 'mini.indentscope'
		Load_plugin 'utilyre/sentiment.nvim'
		Load_plugin 'hadronized/hop.nvim'
		-- if not vim.g.neovide and vim.env.TERM ~= 'xterm-kitty' then
		-- 	Load_Plugin 'sphamba/smear-cursor.nvim'
		-- end
	end
})
		Load_plugin 'altermo/ultimate-autopair.nvim'
au({ 'CmdlineEnter' }, {
    once = true,
    callback = function()
		Load_cmdln()
    end
})
local function Load_cmdln()
	require 'command'
	require 'fzf'
	Load_plugin 'stevearc/oil.nvim'
end
        vim.pack.add({ url })
        local modname = pluginOptions[plugname].modname
        local url = 'https://github.com/' .. plugname

local map = vim.keymap.set
return {
    ['folke/flash.nvim'] = {
        modname = 'flash',
        opts = {},
        callback = function()
            local flash = require 'flash'
            flash.toggle(true)
        end
    },
    ['gbprod/substitute.nvim'] = {
        modname = 'substitute',
        callback = function()
            local sub = require 'substitute'
            map('n', 's', sub.operator)
            map('n', 'ss', sub.line)
            map('n', 'S', sub.eol)
            map('x', 's', sub.visual)
        end
    },
    ['kylechui/nvim-surround'] = {
        modname = 'nvim-surround',
        opts = {},
    },
    ['stevearc/oil.nvim'] = {
        modname = 'oil',
        opts = {
            columns = {
                'icon',
                'permission',
                'size',
                'mtime'
            },
        },
        callback = function()
            map('n', '^o', require 'oil'.toggle_float)
        end,
        dependencies = { 'nvim-tree/nvim-web-devicons' }
    },
    ['altermo/ultimate-autopair.nvim'] = {
        modname = 'ultimate-autopair',
        opts = {
            fastwarp = {
                rmap = '<A-y>',
                rcmap = '<A-y>',
            },
            tabout = {
                multi = true,
                enable = true,
                hopout = true,
            },
            bs = {
                indent_ignore = true,
            },
            space2 = {
                enable = true,
            },
            extensions = {
                fly = {
                    multiline = true,
                    enable = true
                },
            }
        },
    },
    ['utilyre/sentiment.nvim'] = {
        modname = 'sentiment',
        opts = {},
        callback = function()
            vim.g.loaded_matchparen = 1
        end
    },
    ['nvim-tree/nvim-web-devicons'] = {},
    ['niuiic/core.nvim'] = {},
    ['niui/track.nvim'] = {
        modname = 'track',
        opts = {},
        callback = function()
            local track = require 'track'
            local markfile = vim.fn.stdpath('data') .. '/marks/mark.json'
            map('n', 'ma', track.add_mark)
            map('n', 'mA', track.add_flow)
            map('n', 'md', track.delete_mark)
            map('n', 'mD', track.delete_flow)
            map('n', 'mu', track.update_mark)
            map('n', 'mU', track.update_flow)
            map('n', 'ms', function() track.store_marks(markfile) end)
            track.restore_marks(markfile)
        end,
        dependencies = {
            'nvim-lua/plenary.nvim',
            'nvim-telescope/telescope.nvim',
            'niuiic/core.nvim',
        },
    },
    ['nvim-lua/plenary.nvim'] = {},
    ['nvim-telescope/telescope.nvim'] = {
        modname = 'telescope',
        opts = {},
        dependencies = {
            'nvim-lua/plenary.nvim',
        },
    },
    ['hadronized/hop.nvim'] = {
        modname = 'hop',
        opts = {},
        callback = function()
            local hop = require 'hop'
            map({ 'n', 'v', 'o' }, 'gw', hop.hint_words)
            map({ 'n', 'v', 'o' }, 'ga', hop.hint_anywhere)
        end
    },
    ['zbirenbaum/copilot.lua'] = {
        modname = 'copilot',
        opts = {
            suggestion = {
                enabled = true,
                auto_trigger = false,
                keymap = {
                    accept = '<C-S-y>',
                    next = '<C-S-n>',
                    prev = '<C-S-p>',
                    dismiss = '<C-S-e>',
                }
            },
            filetypes = {
                gitcommit = true
            }
        },
        callback = function()
            map('n', '^a', require 'copilot.suggestion'.toggle_auto_trigger)
        end
    },
    ['nvim-treesitter/nvim-treesitter'] = {
        modname = 'nvim-treesitter',
        opts = { ensure_installed = 'all' },
    },
    ['SmiteshP/nvim-navic'] = {
        modname = 'nvim-navic',
        opts = {
            lsp = { auto_attach = true },
            highlight = true
        }
    },
    ['SmiteshP/nvim-navbuddy'] = {
        modname = 'nvim-navbuddy',
        opts = {
            lsp = { auto_attach = true },
            highlight = true
        },
        dependencies = {
            'SmiteshP/nvim-navic',
            'MunifTanjim/nui.nvim'
        }
    },
    ['MunifTanjim/nui.nvim'] = {
        modname = 'nui',
    },
    ['andersevenrud/nvim_context_vt'] = {
        modname = 'nvim_context_vt',
        opts = {
            enabled = true,
        },
    },
    ['sphamba/smear-cursor.nvim'] = {
        modname = 'smear_cursor',
        opts = {},
    },
}

local mysnip = {}
local map = vim.keymap.set
M = {}
function M.set_snip(sn)
	mysnip[sn.abbr] = sn.snip
end
function M.setup_keymap()
	map('i', '<Tab>', function()
		local curpos = vim.api.nvim_win_get_cursor(0);
		if curpos[2] == 0 then return '<Tab>' end
		local newpos = { curpos[1], curpos[2] - 1 }
		vim.api.nvim_win_set_cursor(0, newpos)
		local cword = vim.fn.expand('<cword>')
		local snip = mysnip[cword]
		if snip then
			return '<Esc>ciw<cmd>lua vim.snippet.expand"' .. snip:gsub('\n', '\\n') .. '"<CR>'
		end
		vim.api.nvim_win_set_cursor(0, curpos)
		if vim.snippet.active({ direction = 1 }) then
			return '<cmd>lua vim.snippet.jump(1)'
		else
			return '<Tab>'
		end
	end, { expr = true })
	map({ 'i', 's' }, '<S-Tab>', function()
		if vim.snippet.active({ direction = -1 }) then
			vim.snippet.jump(-1)
		else
			return '<S-Tab>'
		end
	end, { expr = true })
end
return M

M = {}
---@param str string
---@return string
local function make_uniq(str)
	return '<Plug>(' .. str .. ')'
end
local function map(mode, lhs, rhs, remap)
end
---@class Autos
---@field entering (fun(): string?|string)?
---@field repeating (fun(): string?|string)?
---@field leaving (fun(): string?|string)? (reserved)
---@class Follower
---@field key string
---@field run_when Autos?
---@param mode string|string[]
---@param leader string
---@param followers Follower[]
function M.set_submode_keymap(mode, leader, followers)
	local uniqid = make_uniq(leader)
	local uniqprefix = uniqid .. leader
	for _, follower in ipairs(followers) do
		local key = leader .. follower.key
		local run_when = follower.run_when or {}
		local get_rhs = function(any)
			if not any then
				return key .. uniqprefix
			elseif type(any) == 'string' then
				return any .. uniqprefix
				return function()
					return (any() or '') .. uniqprefix
				end
			end
		end
		map(mode, key, get_rhs(run_when.entering), true)
		map(mode, uniqprefix .. follower.key, get_rhs(run_when.repeating), true)
	end
	map(mode, uniqprefix, '', true)
end
---@class AccOpts
---@field base number?
---@field thre number?
---@param mode string|string[]
---@param key string
---@param callback (fun(): string?)?
---@param opts AccOpts?
function M.acceleration_key(mode, key, callback, opts)
	local uniqid = make_uniq(key)
	local count ---@type number
	local base = opts and opts.base or 2
	local thre = opts and opts.thre or 3
	vim.keymap.set(mode, key, function()
		if vim.v.count > 0 then
			return key
		end
		count = 1
		if callback then
			return (callback() or '') .. uniqid
		end
		return key .. uniqid
	end, { expr = true })
	vim.keymap.set(mode, uniqid .. key, function()
		local speed = math.pow(base, math.floor(count / thre))
		count = count + 1
		if callback then
			return speed .. (callback() or key) .. uniqid
		end
		return speed .. key .. uniqid
	end, { expr = true })
	vim.keymap.set(mode, uniqid, '<Nop>')
end
return M
			elseif vim.is_callable(any) then
	vim.keymap.set(mode, lhs, rhs, { expr = vim.is_callable(rhs), remap = remap })

local extui = require 'vim._extui'
extui.enable({
    enable = true
})

M = {}
function M.get_visual_selection()
end
return M
  local buf = vim.api.nvim_get_current_buf()
  local start = vim.api.nvim_buf_get_mark(buf, '<')
  local end_ = vim.api.nvim_buf_get_mark(buf, '>')
  return vim.range(start[1], start[2], end_[1], end_[2])

M = {}
function M.open_wrapwin()
	local curwin = vim.api.nvim_tabpage_get_win(0)
	local newwin = vim.api.nvim_open_win(0, false, { split = 'left' })
	local winheight = vim.api.nvim_win_get_height(0)
	local winbot = vim.fn.line('w$')
	local targetline = winbot + math.floor(winheight / 2) - 1
	-- scroll new window page forward
	vim.api.nvim_win_set_cursor(0, { targetline, 1 })
	vim.cmd.normal 'zz'
	-- enable scrollbind for both
	vim.o.scrollbind = true
	vim.api.nvim_tabpage_set_win(0, newwin)
	vim.o.scrollbind = true
	-- delete only new window
	vim.keymap.set('n', '<C-c>', function()
		vim.api.nvim_win_close(newwin, false)
		vim.keymap.set('n', 'Q', 'ZZ')
	end, { buffer = true })
	-- delete both of windows
	vim.keymap.set('n', 'Q', function()
		vim.api.nvim_win_close(newwin, false)
		vim.api.nvim_tabpage_set_win(0, curwin)
		vim.cmd.quit()
	end, { buffer = true })
	vim.keymap.set('n', '<C-f>', '2<C-f>', { buffer = true })
	vim.keymap.set('n', '<C-b>', '2<C-b>', { buffer = true })
	vim.keymap.set('n', '<C-d>', '<C-f>', { buffer = true })
	vim.keymap.set('n', '<C-u>', '<C-b>', { buffer = true })
end
return M

const std = @import("std");
const String = []const u8;
const List = []const []const u8;
const plugin_path = "plugins";
const plugins = [_]String{
    "MunifTanjim/nui.nvim",
    "SmiteshP/nvim-navbuddy",
    "SmiteshP/nvim-navic",
    "altermo/ultimate-autopair.nvim",
    "andersevenrud/nvim_context_vt",
    "folke/flash.nvim",
    "gbprod/substitute.nvim",
    "hadronized/hop.nvim",
    "kylechui/nvim-surround",
    "niuiic/core.nvim",
    "niuiic/track.nvim",
    "nvim-lua/plenary.nvim",
    "nvim-telescope/telescope.nvim",
    "nvim-tree/nvim-web-devicons",
    "nvim-treesitter/nvim-treesitter",
    "stevearc/oil.nvim",
    "utilyre/sentiment.nvim",
    "vim-jp/nvimdoc-ja",
    "vim-jp/vimdoc-ja",
    "zbirenbaum/copilot.lua",
    "sphamba/smear-cursor.nvim",
    "neovim/neovim",
};
pub fn build(b: *std.Build) void {
    const cwd = b.build_root.path.?;
    const plugin_dir = b.fmt("{s}/plugins", .{ cwd });
    const plug_sync_step = b.step("plug-sync", "sync plugins");
    _ = .{ b, plugin_dir, plug_sync_step };
}

local fuzpath = require 'fuzpath'
local id = { name = 1, count = 2 }
---@param tbl table<string, number>[]
---@param val string
local function insert(tbl, val)
	table.insert(tbl, { val, 1 })
end
---@param rec1 table<string, number>
---@param rec2 table<string, number>
---@return boolean
local function compare(rec1, rec2)
	return rec1[id.count] > rec2[id.count]
end
---@param name string
---@return table<string, number>
local function readfile(name)
	local ret = {}
	local fp = io.open(name, 'r')
	if not fp then return {} end
	for line in fp:lines() do
		table.insert(ret, vim.split(line, ','))
	end
	fp:close()
	table.sort(ret, compare)
	return ret
end
local logfile = vim.fn.stdpath('data') .. '/cdtrack/dir.log'
local dirs_table = readfile(logfile)
---@param self table
---@param n number
---@return table
local function getcol(self, n)
	return vim.tbl_map(function(row)
		return row[n]
	end, self)
end
local cwd = vim.uv.cwd()
if not vim.tbl_contains(getcol(dirs_table, id.name), cwd) then
	insert(dirs_table, cwd)
end
---@param dirs table<string, number>[]
---@param dir string
---@return number?
local function finddirrecord(dirs, dir)
	for _, rec in ipairs(dirs) do
		if rec[id.name] == dir then
			return _
		end
	end
end
---@param dirs table<string, number>[]
---@param dir string
local function update_record(dirs, dir)
	local index = finddirrecord(dirs, dir)
	if index then
		dirs[index][id.count] = dirs[index][id.count] + 1
	else
		insert(dirs, dir)
	end
end
local function normalize_path(dir)
	local isrel = dir:sub(1, 1) ~= '/'
	local base = isrel and vim.uv.cwd() .. '/' or ''
	return vim.fs.normalize(base .. dir)
end
local function rm_nonexistpath(pathtbl)
	local i = 1
	while i <= #pathtbl do
		if vim.uv.fs_stat(pathtbl[i]) then
			i = i + 1
		else
			table.remove(pathtbl, i)
		end
	end
	return pathtbl
end
---@param trigger string
---@return string[]
local function findmatch(trigger)
	local matched = fuzpath.fuzpath(getcol(dirs_table, id.name), trigger)
	return rm_nonexistpath(matched)
end
---@param input string
local function cdtrack(input)
	local dir = normalize_path(input)
	if not vim.uv.fs_stat(dir) then
		local candidates = findmatch(input)
		if #candidates == 0 then
			print('No such directory ' .. dir)
			return
		end
		if #candidates == 1 then
			dir = candidates[1]
		else
			vim.ui.select(candidates, { prompt = 'Select Directory:' }, function(choise)
				dir = choise
			end)
		end
	end
	vim.cmd.cd(dir)
end
vim.api.nvim_create_user_command('Z', function(opts)
	cdtrack(opts.fargs[1])
end, { nargs = 1, bar = true, complete = findmatch })
vim.keymap.set('n', 'Zf', function()
	vim.ui.input({ prompt = 'cdtrack: ', complete = findmatch }, cdtrack)
end)
vim.api.nvim_create_autocmd('DirChanged', {
	callback = function()
		update_record(dirs_table, vim.uv.cwd())
	end
})
vim.api.nvim_create_autocmd('VimLeave', {
	callback = function()
		-- ensure directory exists
		if vim.fn.mkdir(vim.fn.fnamemodify(logfile, ':p:h'), 'p') ~= 1 then return end
		local buf = table.concat(vim.tbl_map(function(row)
			return table.concat(row, ',')
		end, dirs_table), '\n')
		local fp = io.open(logfile, 'w')
		if not fp then return end -- no one wants to see errors when leaving
		fp:write(buf)
		fp:close()
	end
})

(local au vim.api.nvim_create_autocmd)
(local m vim.keymap.set)
(fn Treesitter_config []
  (let [prefix (.. vim.env.HOME "/.local/share/nvim/runtime/queries/")]
    (if (and (> (length vim.o.filetype) 0) (vim.uv.fs_stat (.. prefix vim.o.filetype)))
        (vim.treesitter.start))))
(au ["VimEnter"]
    { :callback
      #(let [session (.. vim.env.HOME "/.cache/nvim/")]
         (when (vim.uv.fs_stat session)
           (vim.cmd.source session)
           (vim.fs.rm session))) })
(au ["UIEnter"]
    { :callback
      #((require "map")
        (vim.cmd.shada)
        (if (= 0 (vim.fn.argc))
            (vim.cmd.term "nu")
            (vim.cmd.normal "g`\""))) })
(au ["FileType"]
    { :callback Treesitter_config })
(au ["CmdLineEnter"]
    { :callback
      #(require "cdtrack")
      :once true })
(au ["TextYankPost"]
    { :callback
      #(if (= "" vim.v.event.regname)
           (vim.fn.setreg vim.v.event.operator (vim.fn.getreg)))})
(au ["CmdWinEnter"]
    { :callback
      #((m "n" "<ESC>" "<cmd>q!<CR>" { :buffer true })
        (tset vim :bo :filetype "vim")) })
(au ["BufWinEnter"]
    { :pattern "COMMIT_EDITMSG"
      :callback
      #(icollect [i s (ipairs (vim.fn.systemlist "git diff --cached"))]
         (vim.fn.append (- i 1) (.. "# " s)))})
(au ["BufWritePre"]
    { :callback
      #(let [dir (vim.fn.expand :<afile>:p:h)
             f   (io.open dir :r)]
         (if f
             (f:close)
             (vim.fn.mkdir dir :p)))})
(au ["VimLeave"] { :command "wshada" })
nil

(local ns
       { :green         "#07d101"
	     :blue          "#00bfff"
	     :cream         "#edf0e0"
	     :pink          "#f584c6"
	     :red           "#f85624"
	     :dustypink     "#d8916e"
	     :navy          "#0047ab"
	     :gray          "#c0c0c0"
	     :greenyellow   "#adff2f"
	     :electriclime  "#ccff00"
	     :darkgreen     "#228b22"
	     :lightpink     "#ffb7c5"
	     :gold          "#ffd700" })
(local hi (partial vim.api.nvim_set_hl 0))
(hi :Normal        { :bg "none" })
(hi :NormalNC      { :bg "none" })
(hi :SignColumn    { :bg "none" })
(hi :CursorLine    { :bg "none" })
(hi :CursorLineNR  { :bg "none" :fg ns.red :bold true })
(hi :CursorLineNC  { :bg "none" })
(hi :LineNr        { :bg "none" :fg ns.navy })
(hi :StatusLine    { :bg "none" })
(hi :StatusLineNC  { :bg "none" })
(hi :LspInlayHint  { :fg "DarkCyan" })
(hi :Visual        { :bg ns.blue })
(hi :PmenuSel      { :bg ns.blue :fg ns.gold })
(hi :Search        { :fg ns.cream })
(hi :CurSearch     { :bg ns.cream :fg ns.darkgreen })
(hi :Substitute    { :fg ns.cream })
(hi :WinSeparator  { :fg ns.blue })
(hi :Boolean       { :fg ns.blue })
(hi :Comment       { :fg ns.gray })
(hi :Constant      { :fg ns.pink })
(hi :Statement     { :fg ns.green :bold true })
(hi :KeyWord       { :fg ns.cream :bold true })
(hi :PreProc       { :fg ns.dustypink })
(hi :Identifier    { :fg ns.greenyellow :bold true })
(hi :Special       { :fg ns.blue })
(hi :String        { :fg ns.lightpink })
(hi :Type          { :fg ns.blue :bold true })
(hi :Number        { :fg ns.gold })
(hi :Todo          { :bg ns.cream :fg ns.navy :bold true })
(hi :Operator      { :fg ns.cream })
(hi :Function      { :fg ns.gold })
(hi :SpecialChar   { :fg ns.pink })
(hi :Delimiter     { :fg ns.cream })
(hi "@variable"             { :fg ns.electriclime })
(hi "@variable.parameter"   { :italic true })
nil

(local command vim.api.nvim_create_user_command)
(command "M"
         (lambda [opts]
           (let [args (table.concat opts.fargs " ")]
             (vim.cmd.term (.. "man " args "| bat -p -l man"))
             (vim.cmd.startinsert)))
         { :nargs "*"
           :bar true })
(command "W"
         (lambda [opts]
           (vim.cmd.term (.. "w3m " (. opts.fargs 1)))
           (vim.cmd.startinsert))
         { :nargs 1
           :bar true })
(command "H"
         (lambda [opts]
           (vim.cmd (.. "tab h " (. opts.fargs 1)))
           (. (require "wrapwin") :open-wrapwin))
         { :nargs 1
           :complete "help" })
(command "VS"
         (lambda []
           (. (require "wrapwin") :open-wrapwin))
         { :nargs 0 })
nil

(local dmacro-key "<C-T>")
(local clear-key "<C-S-T>")
(var key-log "")
(var prev-macro nil)
(fn guess-macro [kl]
  (for [i (/ (length kl) 2) (length kl)]
    (let [curspan (kl:sub i)
          srchspan (kl:sub 1 (- i 1))
          [start end] (srchspan:find curspan 1 true)]
      (when (and start end)
          (set prev-macro (srchspan:sub start))
          (srchspan:sub (+ end 1))))))
(fn key-logger [_ typed]
  (let [readable-keycode (vim.fn.keytrans typed)]
    (if (~= readable-keycode dmacro-key)
            (set key-log (.. key-log readable-keycode))
            (if (> (length key-log) 100)
                (set key-log (key-log:sub (- (length key-log) 100))))
            (set prev-macro nil))))
(vim.on_key key-logger)
(vim.keymap.set ["i" "n" "v" "o" "c" "t"] dmacro-key
                #(vim.api.nvim_input (or prev-macro (guess-macro key-log) "")))
(vim.keymap.set ["i" "n" "v" "o" "c" "t"] clear-key
                #(set key-log ""))
nil

(local IM_cmd "fcitx5-remote")
(local toggle_IM [IM_cmd "-t"])
(var was_IM_enabled false)
(fn get_IM_status []
  (= "2" (: (. (: (vim.system [IM_cmd]) :wait) :stdout) :sub 1 1)))
(fn toggle_IM_status []
  (if was_IM_enabled (vim.system toggle_IM)))
(vim.api.nvim_create_autocmd "InsertEnter" { :callback toggle_IM_status })
(vim.api.nvim_create_autocmd "InsertLeave"
                             { :callback
                               (lambda []
                                 (set was_IM_enabled (get_IM_status))
                                 (toggle_IM_status)) })
nil

(local au vim.api.nvim_create_autocmd)
(local snip (require "snippet"))
(fn quickeval [cmd]
  (let [range (. (require "utils") :get-visual-selection)
        start range.start
        end_ range.end_
        content (vim.fn.getregion start end_ { :type (vim.fn.mode 1) })
        tmpfilename (.. "/tmp/nvim-ftplugin." (vim.fn.expand "%:e"))
        file (assert io.open tmpfilename "w")]
    (each [_ line (ipairs content)]
      (file:write (.. line "\n")))
    (file:close)
    (vim.cmd (.. "vert term" cmd tmpfilename))
    (vim.cmd.startinsert)))
(au "FileType"
    { :callback
      (lambda [ev]
        (let [ft ev.match
              [ok ftp] (pcall require (.. "ftplugin." ft))]
          (when ok
              (when ftp.lsp
                  (set ftp.lsp.on_attach (. (require "lsp") :on-attach))
                  (: (vim.uv.new_async (vim.schedule_wrap #(vim.lsp.start ftp.lsp))) :send))
              (if ftp.quickeval_cmd
                  (vim.keymap.set "v" "x" #(quickeval ftp.quickeval_cmd)))
              (if ftp.callback
                  (ftp.callback))
              (when ftp.snippet
                  (snip.setup_keymap)
                  (each [_ sn (ipairs ftp.snippet)]
                    (snip.set_snip sn)))))) })
nil

(fn get-files-recursive [directory files]
  (let [curdir vim.env.PWD
        directory-files (vim.fn.readdir directory)
        ignored-dirs ["." ".." ".git" "build" "bin" "plugins"]]
    (each [_ file (ipairs directory-files)]
      (let [full-path (.. directory "/" file)]
        (if (and (not= 0 (vim.fn.isdirectory full-path)) (not (vim.tbl_contains ignored-dirs file)))
            (get-files-recursive full-path files)
            (table.insert files (full-path:sub (+ 2 (length curdir)))))))
    files)
  (var file-cache nil)
  (vim.api.nvim_create_user_command "F"
                                    (lambda [opts]
                                      (vim.cmd.tabnew (. opts.fargs 1)))
                                    { :nargs 1
                                      :bars true
                                      :complete
                                        (lambda [trigger]
                                          (if (not file-cache)
                                              (set file-cache (get-files-recursive vim.env.PWD {})))
                                          (if (> (length trigger) 0)
                                              (vim.fn.matchfuzzy file-cache trigger)
                                              file-cache)) }))

(local map vim.keymap.set)
(local api vim.api)
(fn print-blame-text []
  (let [curfile (vim.fn.expand "%")
        line (api.nvim_win_get_cursor 0)
        blame (vim.fn.system (string.format "git blame -c -L %d,%d %s" (. line 1) (. line 1) curfile))
        hash (string.match blame "%S+")]
    (print (if (= hash "  00000000")
               "Not Committed Yet"
               (let [cmd (.. "git show " hash " --format='%an | %ar | %s' | head -n 1")]
                 (: (vim.fn.system cmd) :sub 1 -2))))))
(map "n" "\\b" print-blame-text)
nil

(var M {})
(vim.keymap.set "n" "=" vim.lsp.buf.format)
(vim.keymap.set "n" "^h" #(vim.lsp.inlay_hint.enable (not (vim.lsp.inlay_hint.is_enabled))))
(vim.keymap.set "n" "gd" vim.lsp.buf.definition)
(vim.keymap.set "n" "grh" vim.lsp.buf.hover)
(fn M.on_attach [client buf]
  (let [chars (fcollect [i 32 126]
                (string.char i))]
    (tset client :server_capabilities :completionProvider :triggerCharacters chars))
  (vim.lsp.completion.enable
    true
    client.id
    buf
    { :autotrigger true
      :convert #{ :abbr ($.label:gsub "%b()" "") } }))
M

(import-macros {: foreach : foreachMulti} :macros)
(local map vim.keymap.set)
(local submode (require :submode))
(tset vim :g :mapleader " ")
(fn smart-gf []
  (let [fpath (vim.fn.expand "<cfile>")]
    (if (not= "https://" (fpath:sub 1 8))
        (vim.cmd.normal "gF")
        (do
          (vim.cmd.term (.. "w3m " fpath))
          (vim.cmd.startinsert)))))
(fn smart-i []
  (if (: (vim.fn.getline ".") :match "^ *$")
      (vim.api.nvim_input "\"_cc")
      (vim.cmd.startinsert)))
(foreachMulti (partial map :n)
  [[:<BS>      :<c-b>]
   [:<delete>  :<c-f>]
   [:<c-s-e>   :5<c-e>]
   [:<c-s-y>   :5<c-y>]
   [:i         smart-i]
   [:S         :c^]
   [:Q         :ZZ { :noremap true }]
   [:ZZ        #(do (vim.cmd.mksession (.. vim.env.HOME "/.cache/nvim/session.nvim")) (vim.cmd.wqa))]
   [:gk        :25k]
   [:gj        :25j]
   [:gf        smart-gf]
   [:gb        vim.cmd.bnext]
   [:gB        vim.cmd.bprev]
   [:^n        #(tset vim :o :number (not vim.o.number))]
   [:^r        #(tset vim :o :relativenumber (not vim.o.relativenumber))]
   [:^s        #(tset vim :o :spell (not vim.o.spell))]
   [:<c-z>     :<cmd>w<CR><c-z>]
   [:zS        vim.show_pos]
   ])
(foreachMulti (partial map [:n :v])
  [["q;" :q:]
   ])
(foreachMulti (partial map [:n :v :o])
  [[:K :5k]
   [:J :5j]
   [:gl :$l]
   [:gh :^]
   ["]b" "])"]
   ["[b" "[("]
   ["]B" "]}"]
   ["[B" "[{"]
   ])
(foreachMulti (partial map "i")
  [[:<esc> :<right><esc>]
   ])
(foreachMulti (partial map "v")
  [[:v :<c-v>]
   [:aa :VggoG]
   ])
(foreachMulti (partial map "o")
  [[:. :i>]
   [:iq "i'"]
   [:iQ "i\""]
   [:aq "a'"]
   [:aQ "a\""]
   [:i<space> :iW]
   [:a<space> :aW]
   ])
(foreachMulti (partial map "t")
  [[:<c-\\> :<c-\\><c-n>]
   ])
(submode.set-submode-keymap "n" "g"
  [{ :key "t" }
   { :key "T" }
   { :key "e" }
   { :key "E" }
   { :key "J" }
   ])
(submode.set-submode-keymap "n" "d"
  [{ :key "h" }
   { :key "l" }
   ])
(submode.set-submode-keymap "n" "<c-w>"
  [{ :key ">" }
   { :key "<" }
   { :key "+" }
   { :key "-" }
   { :key "h" }
   { :key "j" }
   { :key "k" }
   { :key "l" }
   ])
(submode.set-submode-keymap "n" "z"
  [{ :key "<space>" :run-when { :entering "<c-f>" :repeating "<c-f>" } }
   { :key "b"       :run-when { :entering "<c-b>" :repeating "<c-b>" } }
   ])
(submode.set-submode-keymap "n" "*"
  [{ :key "*" :run-when { :entering "#*" :repeating "*" } }
   { :key "#" :run-when { :entering "*#" :repeating "#" } }
   ])
(foreach (partial submode.acceleration-key :n)
  [:h
   :j
   :k
   :l
   ])
(fn safe-cabbr [lhs rhs]
  (vim.cmd (.. "cabbrev <expr>" lhs " (getcmdtype() ==# ':' && getcmdline() ==# '" lhs "') ? '" rhs "' : '" lhs "'")))
(safe-cabbr "r" "lua require")
(safe-cabbr "l" "lua")
nil

(local o vim.opt)
(tset o :autoread true)
(tset o :autowrite true)
(tset o :complete "w,i,d,kspell")
(tset o :completeopt "menuone,preinsert,noselect,popup,fuzzy")
(tset o :cursorline true)
(tset o :expandtab true)
(tset o :foldmethod "manual")
(tset o :fillchars { :stl " " :stlnc " " })
(tset o :gdefault true)
(tset o :guicursor "n-v-c-sm:block,i-ci-ve:ver25-blinkwait1000-blinkoff300-blinkon1000,t:block-TermCursor")
(tset o :guifont "PlemolJP35 Console NF:h8")
(tset o :helplang "ja,en")
(tset o :hidden true)
(tset o :ignorecase true)
(tset o :hlsearch false)
(tset o :incsearch false)
(tset o :laststatus 0)
(tset o :mouse "")
(tset o :number false)
(tset o :paragraphs "")
(tset o :path ".,,,**")
(tset o :ruler false)
(tset o :scrolloff 10)
(tset o :shada "")
(tset o :shell "/run/current-system/sw/bin/zsh")
(tset o :shiftwidth 4)
(tset o :showcmd false)
(tset o :showmode false)
(tset o :showtabline 0)
(tset o :signcolumn "yes")
(tset o :smartcase true)
(tset o :smartindent true)
(tset o :statusline " ")
(tset o :tabstop 4)
(tset o :termguicolors true)
(tset o :textwidth 0)
(tset o :timeout false)
(tset o :undodir (.. (vim.fn.stdpath :data) "/undo"))
(tset o :undofile true)
(tset o :wildmenu true)
(tset o :wrap false)
(tset vim :g :copilot_filetypes { :gitcommit true :yaml true :markdown true })
(when vim.g.neovide
	(tset vim :g :neovide_hide_mouse_when_typing true)
	(tset vim :g :neovide_opacity 1.0)
	(tset vim :g :transparency 1.0)
	(tset vim :g :neovide_text_gamma 0)
	(tset vim :g :neovide_text_contrast 0.0)
	(tset vim :g :terminal_color_0  :#171717) ; black
	(tset vim :g :terminal_color_1  :#d81765) ; normal red
	(tset vim :g :terminal_color_2  :#97d01a) ; normal green
	(tset vim :g :terminal_color_3  :#ffa800) ; normal yellow
	(tset vim :g :terminal_color_4  :#16b1fb) ; normal blue
	(tset vim :g :terminal_color_5  :#ff2491) ; normal magenta
	(tset vim :g :terminal_color_6  :#0fdcb6) ; normal cyan
	(tset vim :g :terminal_color_7  :#ebebeb) ; light gray
	(tset vim :g :terminal_color_8  :#88757c) ; dark gray
	(tset vim :g :terminal_color_9  :#ff0000) ; bright red
	(tset vim :g :terminal_color_10 :#76b639) ; bright green
	(tset vim :g :terminal_color_11 :#f7b125) ; bright yellow
	(tset vim :g :terminal_color_12 :#289cd5) ; bright blue
	(tset vim :g :terminal_color_13 :#ff2491) ; bright magenta
	(tset vim :g :terminal_color_14 :#0a9b81) ; bright cyan
	(tset vim :g :terminal_color_15 :#f8f8f8) ; white
  )

(import-macros {: foreach} :macros)
(local au vim.api.nvim_create_autocmd)
(local map vim.keymap.set)
(local pluginOptions (require :plugindata))
(fn Load_plugin [plugname]
  (when (. pluginOptions plugname)
    (let [url (.. "https://github.com/" plugname)
          p (partial . pluginOptions plugname)
          { : modname : opts : callback : dependencies } p]
      (when dependencies
        (each [_ dep (ipairs dependencies)]
          (Load_plugin dep)))
      (vim.pack.add [url])
      (when opts ((. (require modname) :setup) opts))
      (when callback (callback))
      (tset pluginOptions plugname nil))))
(au [:UIEnter]
    { :callback
      #(foreach Load_plugin
                [:folke/flash.nvim
                 :gbprod/substitute.nvim
                 :kylechui/nvim-surround
                 :andersecenrud/nvim_context_vt])})
(map :n :^a
     #((Load_plugin :zbirenbaum/copilot.lua)
       (let [sug (require :copilot.suggestion)]
         (map :n :^a sug.toggle_auto_trigger)
         (sug.toggle_auto_trigger))))
(map :n :g/
     #((Load_plugin :nvim-telescope/telescope.nvim)
       (let [tb (require :telescope.builtin)]
         (map :n :g/ tb.live_grep)
         (tb.live_grep))))
(map :n :m
     #((Load_plugin :niuiic/track.nvim)
       (vim.keymap.del :n :m)
       (vim.fn.feedkeys :m)))
(map :n :<a-n>
     #((Load_plugin :SmiteshP/nvim-navbuddy)
       (map :n :<a-n> vim.cmd.Navbuddy)
       (vim.cmd.Navbuddy)))
(fn Load_cmdln []
  (require :command)
  (require :fzf)
  (Load_plugin :stevearc/oil.nvim))
(au [:CmdlineEnter]
    { :once true
      :callback Load_cmdln })
(au [:InsertEnter :CmdlineEnter]
    { :once true
      :callback
      #(Load_plugin :altermo/ultimate-autopair.nvim)})
(au [:CursorMoved]
    { :once true
      :callback
      #((Load_plugin :mini.indentscope)
        (Load_plugin :utilyre/sentiment.nvim)
        (Load_plugin :hadronized/hop.nvim))})

(import-macros {: foreachMulti} :macros)
(local map vim.keymap.set)
{ :folke/flash.nvim
  { :modname "flash"
    :opts    {}
    :callback
    #((: (require :flash) :toggle true)) }
  :gbprod/substitute.nvim
  { :modname "substitute"
    :callback
    #(let [sub (require :substitute)]
       (map :n :s sub.operator)
       (map :n :ss sub.line)
       (map :n :S sub.eol)
       (map :x :s sub.visual)) }
  :kylechui/nvim-surround
  { :modname "nvim-surround"
    :opts    {} }
  :stevearc/oil.nvim
  { :modname "oil"
    :opts
    { :columns [:icon :permission :size :mtime] }
    :callback
    #(map :n :^o (. (require :oil) :toggle_float)) }
  :altermo/ultimate-autopair.nvim
  { :modname "ultimate-autopair"
    :opts
    { :fastwarp { :rmap "<a-y>" :rcmap "<a-y>" }
      :tabout   { :enable true :multi true :hopout true }
      :bs       { :indent_ignore true }
      :space2   { :enable true }
      :extensions { :fly { :enable true :multiline true } } } }
  :utilyre/sentiment.nvim
  { :modname "sentiment"
    :opts    {}
    :callback #(tset vim :g :loaded_matchparen 1) }
  :niui/track.nvim
  { :modname "trach"
    :opts    {}
    :callback
    #(let [track (require :track) markfile (.. (vim.fn.stdpath :data) "marks/mark.json")]
       (foreachMulti (partial map :n)
         [[:ma track.add_mark]
          [:mA track.add_flow]
          [:md track.delete_mark]
          [:mD track.delete_flow]
          [:mu track.update_mark]
          [:mU track.update_flow]
          [:ms #(track.store_marks markfile)]])
       (track.restore_marks markfile)) }
  :nvim-telescope/telescope.nvim
  { :modname "telescope"
    :opts    {}
    :dependencies [:nvim-lua/plenary.nvim] }
  :hadronized/hop.nvim
  { :modname "hop"
    :opts    {}
    :callback
    #(let [hop (require :hop)]
       (foreachMulti (partial map [:n :v :o])
         [[:gw hop.hint_words]
          [:ga hop.hint_anywhere]])) }
  :zbirenbaum/copilot.lua
  { :modname "copilot"
    :opts
    { :suggestion
      { :enabled true
        :auto_trigger false
        :keymap
        { :accept   :<c-s-y>
          :next     :<c-s-n>
          :prev     :<c-s-p>
          :dismiss  :<c-s-e> } }
      :filetypes { :gitcommit true } } }
  :nvim-treesitter/nvim-treesitter
  { :modname :nvim-treesitter
    :opts    { :ensure_installed "all" } }
  :SmiteshP/nvim-navic
  { :modname "nvim-navic"
    :opts
    { :lsp { :auto_attach true }
      :highlight true} }
  :SmiteshP/nvim-navbuddy
  { :modname "nvim-navbuddy"
    :opts
    { :lsp { :auto_attach true }
      :highlight true }
    :dependencies [:SmiteshP/nvim-navic :MunifTanjim/nui.nvim] }
  :MunifTanjim/nui.nvim { :modname "nui" }
  :andersevenrud/nvim_context_vt
  { :modname "nvim_context_vt"
    :opts    { :enabled true } }
  :sphamba/smear-cursor.nvim
  { :modname "smear_cursor"
    :opts    {} }
  :nvim-tree/nvim-web-devicons {}
  :niuiic/core.nvim {}
  :nvim-lua/plenary.nvim {}
}

(local mysnip {})
(local M {})
(local map vim.keymap.set)
(fn M.set-snip [sn]
  (tset mysnip sn.abbr sn.snip))
(fn M.setup-keymap []
  (map :i :<tab>
       #(let [[row col] (vim.api.nvim_win_get_cursor 0)]
          (if (= 0 col)
              :<tab>
              (let [newpos [row (- col 1)]
                    cword (vim.fn.expand :<cword>)
                    snip (. mysnip cword)]
                (vim.api.nvim_win_set_cursor 0 newpos)
                (if snip
                    (.. "<esc>ciw<cmd>lua vim.snippet.expand'" (snip:gsub "\n" "\\n") "'<cr>")
                    (do (vim.api.nvim_win_set_cursor 0 curpos)
                        (if (vim.snippet.active { :direction 1 })
                            "<cmd>lua vim.snippet.jump(1)"
                            "<tab>"))))))
       { :expr true })
  (map [:i :s] :<s-tab>
       #(if (vim.snippet.active { :direction 1 })
            (vim.snippet.jump -1)
            :<s-tab>)
       { :expr true }))
M

(local M {})
(fn make-uniq [str]
  (.. "<plug>(" str ")"))
(fn map [mode lhs rhs remap]
  (vim.keymap.set mode lhs rhs { :expr (vim.is_callable rhs) :remap remap }))
;;;@class Autos
;;;@field entering (fun(): string?|string)?
;;;@field repeating (fun(): string?|string)?
;;;@field leaving (fun(): string?|string)? (reserved)
;;;@class Follower
;;;@field key string
;;;@field run-when Autos?
;;;@param mode string|string[]
;;;@param leader string
;;;@param followers Follower[]
(fn M.set-submode-keymap [mode leader followers]
  (let [uniqid (make-uniq leader)
        uniqpre (.. uniqid leader)]
    (each [_ {: key : run-when} (ipairs followers)]
      (let [k (.. leader key)
            get-rhs (lambda [any]
                      (case (type any)
                        :nil :nil
                        :string (.. any uniqpre)
                        :function (.. (or (any) "") uniqpre)
                        _ (.. k uniqpre)))]
        (map mode k (get-rhs run-when.entering) true)
        (map mode (.. uniqpre key) (get-rhs run-when.repeating) true)))
    (map mode uniqpre "" true)))
;;;@class AccOpts
;;;@field base number?
;;;@field thre number?
;;;@param mode string|string[]
;;;@param key string
;;;@param callback (fun(): string?)?
;;;@param opts AccOpts?
(fn M.acceleration-key [mode key callback opts]
  (let [uniqid (make-uniq key)
        base (if opts opts.base 2)
        thre (if opts opts.thre 3)]
    (var count 0)
    (vim.keymap.set mode key
      #(if (> vim.v.count 0)
           key
           (do
             (set count 1)
             (if callback
                 (.. (or (callback) "") uniqid)
                 (.. key uniqid)))))
    (vim.keymap.set mode (.. uniqid key)
      #(let [spped (math.pow base (math.floor (/ count thre)))]
         (set count (+ count 1))
         (if callback
             (.. speed (or (callback) key) uniqid)
             (.. speed key uniqid)))
      { :expr true })
    (vim.keymap.set mode uniqid "")))
M

(local extui (require :vim._extui))
(extui.enable { :enable true })

(local M {})
(fn M.get-visual-selection []
  (let [buf (vim.api.nvim_get_current_buf)
        [s-row s-col] (vim.api.nvim_buf_get_mark buf :<)
        [e-row e-col] (vim.api.nvim_buf_get_mark buf :>)]
    (vim.range s-row s-col e-row e-col)))
M

(local M {})
(fn M.open-wrapwin []
  (let [curwin (vim.api.nvim_tabpage_get_win 0)
        newwin (vim.api.nvim_open_win 0 false { :split :left })
        winheight (vim.api.nvim_win_get_height 0)
        winbot (vim.fn.line :w$)
        targetline (+ winbot (math.floor (/ winheight 2) -1))]
    ; scroll new window page forward
    (vim.api.nvim_win_set_cursor 0 [targetline 1])
    (vim.cmd.normal :zz)
    ; enable scrollbind for both
    (tset vim :o :scrollbind true)
    (vim.api.nvim_tabpage_set_win 0 newwin)
    (tset vim :o :scrollbind true)
    ; delete only new window
    (vim.keymap.set :n :<c-c>
      #((vim.api.nvim_win_close newwin false)
        (vim.keymap.set :n :Q :ZZ))
      { :buffer true })
    ; delete both of windows
    (vim.keymap.set :n :Q
      #((vim.api.nvim_win_close newwin false)
        (vim.api.nvim_tabpage_set_win 0 curwin)
        (vim.cmd.quit))
      { :buffer true })
    (vim.keymap.set :n :<c-f> :2<c-f> { :buffer true })
    (vim.keymap.set :n :<c-b> :2<c-b> { :buffer true })
    (vim.keymap.set :n :<c-d> :<c-f> { :buffer true })
    (vim.keymap.set :n :<c-u> :<c-b> { :buffer true })))
M

(tset vim :opt :runtimepath "~/.config/nvim,~/.local/share/nvim/runtime,~/.local/lib/nvim")
(let [clibpath (.. (vim.fn.stdpath "config") "/lib/?.so")]
  (tset package :cpath (.. package.cpath ";" clibpath)))
nil

(fn foreach [f lst]
  `(do ,(unpack
     (icollect [_ v (ipairs lst)]
       `(,f ,v)))))
(fn foreachMulti [f lst]
  `(do ,(unpack
      (icollect [_ v (ipairs lst)]
        `(,f (table.unpack ,v))))))
{: foreach : foreachMulti}

    ./nvim
    ./helix

    (import ./emacs pkgs)

    (import ./editor pkgs)

(fn foreach [f lst]
  `(do ,(unpack
     (icollect [_ v (ipairs lst)]
       `(,f ,v)))))
(fn foreachMulti [f lst]
  `(do ,(unpack
      (icollect [_ v (ipairs lst)]
        `(,f (table.unpack ,v))))))
{: foreach : foreachMulti}

M = {}
function M.open_wrapwin()
	local curwin = vim.api.nvim_tabpage_get_win(0)
	local newwin = vim.api.nvim_open_win(0, false, { split = 'left' })
	local winheight = vim.api.nvim_win_get_height(0)
	local winbot = vim.fn.line('w$')
	local targetline = winbot + math.floor(winheight / 2) - 1
	-- scroll new window page forward
	vim.api.nvim_win_set_cursor(0, { targetline, 1 })
	vim.cmd.normal 'zz'
	-- enable scrollbind for both
	vim.o.scrollbind = true
	vim.api.nvim_tabpage_set_win(0, newwin)
	vim.o.scrollbind = true
	-- delete only new window
	vim.keymap.set('n', '<C-c>', function()
		vim.api.nvim_win_close(newwin, false)
		vim.keymap.set('n', 'Q', 'ZZ')
	end, { buffer = true })
	-- delete both of windows
	vim.keymap.set('n', 'Q', function()
		vim.api.nvim_win_close(newwin, false)
		vim.api.nvim_tabpage_set_win(0, curwin)
		vim.cmd.quit()
	end, { buffer = true })
	vim.keymap.set('n', '<C-f>', '2<C-f>', { buffer = true })
	vim.keymap.set('n', '<C-b>', '2<C-b>', { buffer = true })
	vim.keymap.set('n', '<C-d>', '<C-f>', { buffer = true })
	vim.keymap.set('n', '<C-u>', '<C-b>', { buffer = true })
end
return M

M = {}
function M.get_visual_selection()
  local buf = vim.api.nvim_get_current_buf()
  local start = vim.api.nvim_buf_get_mark(buf, '<')
  local end_ = vim.api.nvim_buf_get_mark(buf, '>')
  return vim.range(start[1], start[2], end_[1], end_[2])
end
return M

local extui = require 'vim._extui'
extui.enable({
    enable = true
})

M = {}
---@param str string
---@return string
local function make_uniq(str)
	return '<Plug>(' .. str .. ')'
end
local function map(mode, lhs, rhs, remap)
	vim.keymap.set(mode, lhs, rhs, { expr = vim.is_callable(rhs), remap = remap })
end
---@class Autos
---@field entering (fun(): string?|string)?
---@field repeating (fun(): string?|string)?
---@field leaving (fun(): string?|string)? (reserved)
---@class Follower
---@field key string
---@field run_when Autos?
---@param mode string|string[]
---@param leader string
---@param followers Follower[]
function M.set_submode_keymap(mode, leader, followers)
	local uniqid = make_uniq(leader)
	local uniqprefix = uniqid .. leader
	for _, follower in ipairs(followers) do
		local key = leader .. follower.key
		local run_when = follower.run_when or {}
		local get_rhs = function(any)
			if not any then
				return key .. uniqprefix
			elseif type(any) == 'string' then
				return any .. uniqprefix
			elseif vim.is_callable(any) then
				return function()
					return (any() or '') .. uniqprefix
				end
			end
		end
		map(mode, key, get_rhs(run_when.entering), true)
		map(mode, uniqprefix .. follower.key, get_rhs(run_when.repeating), true)
	end
	map(mode, uniqprefix, '', true)
end
---@class AccOpts
---@field base number?
---@field thre number?
---@param mode string|string[]
---@param key string
---@param callback (fun(): string?)?
---@param opts AccOpts?
function M.acceleration_key(mode, key, callback, opts)
	local uniqid = make_uniq(key)
	local count ---@type number
	local base = opts and opts.base or 2
	local thre = opts and opts.thre or 3
	vim.keymap.set(mode, key, function()
		if vim.v.count > 0 then
			return key
		end
		count = 1
		if callback then
			return (callback() or '') .. uniqid
		end
		return key .. uniqid
	end, { expr = true })
	vim.keymap.set(mode, uniqid .. key, function()
		local speed = math.pow(base, math.floor(count / thre))
		count = count + 1
		if callback then
			return speed .. (callback() or key) .. uniqid
		end
		return speed .. key .. uniqid
	end, { expr = true })
	vim.keymap.set(mode, uniqid, '<Nop>')
end
return M

local mysnip = {}
local map = vim.keymap.set
M = {}
function M.set_snip(sn)
	mysnip[sn.abbr] = sn.snip
end
function M.setup_keymap()
	map('i', '<Tab>', function()
		local curpos = vim.api.nvim_win_get_cursor(0);
		if curpos[2] == 0 then return '<Tab>' end
		local newpos = { curpos[1], curpos[2] - 1 }
		vim.api.nvim_win_set_cursor(0, newpos)
		local cword = vim.fn.expand('<cword>')
		local snip = mysnip[cword]
		if snip then
			return '<Esc>ciw<cmd>lua vim.snippet.expand"' .. snip:gsub('\n', '\\n') .. '"<CR>'
		end
		vim.api.nvim_win_set_cursor(0, curpos)
		if vim.snippet.active({ direction = 1 }) then
			return '<cmd>lua vim.snippet.jump(1)'
		else
			return '<Tab>'
		end
	end, { expr = true })
	map({ 'i', 's' }, '<S-Tab>', function()
		if vim.snippet.active({ direction = -1 }) then
			vim.snippet.jump(-1)
		else
			return '<S-Tab>'
		end
	end, { expr = true })
end
return M

local map = vim.keymap.set
return {
    ['folke/flash.nvim'] = {
        modname = 'flash',
        opts = {},
        callback = function()
            local flash = require 'flash'
            flash.toggle(true)
        end
    },
    ['gbprod/substitute.nvim'] = {
        modname = 'substitute',
        callback = function()
            local sub = require 'substitute'
            map('n', 's', sub.operator)
            map('n', 'ss', sub.line)
            map('n', 'S', sub.eol)
            map('x', 's', sub.visual)
        end
    },
    ['kylechui/nvim-surround'] = {
        modname = 'nvim-surround',
        opts = {},
    },
    ['stevearc/oil.nvim'] = {
        modname = 'oil',
        opts = {
            columns = {
                'icon',
                'permission',
                'size',
                'mtime'
            },
        },
        callback = function()
            map('n', '^o', require 'oil'.toggle_float)
        end,
        dependencies = { 'nvim-tree/nvim-web-devicons' }
    },
    ['altermo/ultimate-autopair.nvim'] = {
        modname = 'ultimate-autopair',
        opts = {
            fastwarp = {
                rmap = '<A-y>',
                rcmap = '<A-y>',
            },
            tabout = {
                multi = true,
                enable = true,
                hopout = true,
            },
            bs = {
                indent_ignore = true,
            },
            space2 = {
                enable = true,
            },
            extensions = {
                fly = {
                    multiline = true,
                    enable = true
                },
            }
        },
    },
    ['utilyre/sentiment.nvim'] = {
        modname = 'sentiment',
        opts = {},
        callback = function()
            vim.g.loaded_matchparen = 1
        end
    },
    ['nvim-tree/nvim-web-devicons'] = {},
    ['niuiic/core.nvim'] = {},
    ['niui/track.nvim'] = {
        modname = 'track',
        opts = {},
        callback = function()
            local track = require 'track'
            local markfile = vim.fn.stdpath('data') .. '/marks/mark.json'
            map('n', 'ma', track.add_mark)
            map('n', 'mA', track.add_flow)
            map('n', 'md', track.delete_mark)
            map('n', 'mD', track.delete_flow)
            map('n', 'mu', track.update_mark)
            map('n', 'mU', track.update_flow)
            map('n', 'ms', function() track.store_marks(markfile) end)
            track.restore_marks(markfile)
        end,
        dependencies = {
            'nvim-lua/plenary.nvim',
            'nvim-telescope/telescope.nvim',
            'niuiic/core.nvim',
        },
    },
    ['nvim-lua/plenary.nvim'] = {},
    ['nvim-telescope/telescope.nvim'] = {
        modname = 'telescope',
        opts = {},
        dependencies = {
            'nvim-lua/plenary.nvim',
        },
    },
    ['hadronized/hop.nvim'] = {
        modname = 'hop',
        opts = {},
        callback = function()
            local hop = require 'hop'
            map({ 'n', 'v', 'o' }, 'gw', hop.hint_words)
            map({ 'n', 'v', 'o' }, 'ga', hop.hint_anywhere)
        end
    },
    ['zbirenbaum/copilot.lua'] = {
        modname = 'copilot',
        opts = {
            suggestion = {
                enabled = true,
                auto_trigger = false,
                keymap = {
                    accept = '<C-S-y>',
                    next = '<C-S-n>',
                    prev = '<C-S-p>',
                    dismiss = '<C-S-e>',
                }
            },
            filetypes = {
                gitcommit = true
            }
        },
        callback = function()
            map('n', '^a', require 'copilot.suggestion'.toggle_auto_trigger)
        end
    },
    ['nvim-treesitter/nvim-treesitter'] = {
        modname = 'nvim-treesitter',
        opts = { ensure_installed = 'all' },
    },
    ['SmiteshP/nvim-navic'] = {
        modname = 'nvim-navic',
        opts = {
            lsp = { auto_attach = true },
            highlight = true
        }
    },
    ['SmiteshP/nvim-navbuddy'] = {
        modname = 'nvim-navbuddy',
        opts = {
            lsp = { auto_attach = true },
            highlight = true
        },
        dependencies = {
            'SmiteshP/nvim-navic',
            'MunifTanjim/nui.nvim'
        }
    },
    ['MunifTanjim/nui.nvim'] = {
        modname = 'nui',
    },
    ['andersevenrud/nvim_context_vt'] = {
        modname = 'nvim_context_vt',
        opts = {
            enabled = true,
        },
    },
    ['sphamba/smear-cursor.nvim'] = {
        modname = 'smear_cursor',
        opts = {},
    },
}

local au = vim.api.nvim_create_autocmd
local map = vim.keymap.set
local pluginOptions = require 'plugindata'
---@param plugname string
function Load_plugin(plugname)
	if pluginOptions[plugname] then
        local url = 'https://github.com/' .. plugname
        local modname = pluginOptions[plugname].modname
		local opts = pluginOptions[plugname].opts
		local callback = pluginOptions[plugname].callback
		local dependencies = pluginOptions[plugname].dependencies
		if dependencies then
			for _, dep in ipairs(dependencies) do
				Load_plugin(dep)
			end
		end
        vim.pack.add({ url })
		if opts and modname then require(modname).setup(opts) end
		if callback then callback() end
		pluginOptions[plugname] = nil
	end
end
au({ 'UIEnter' }, {
	callback = function()
		Load_plugin 'folke/flash.nvim'
		Load_plugin 'gbprod/substitute.nvim'
		Load_plugin 'kylechui/nvim-surround'
		Load_plugin 'andersevenrud/nvim_context_vt'
	end
})
map('n', '^a', function()
	Load_plugin 'zbirenbaum/copilot.lua'
	local sug = require 'copilot.suggestion'
	map('n', '^a', sug.toggle_auto_trigger)
	sug.toggle_auto_trigger()
end)
map('n', 'g/', function()
	Load_plugin 'nvim-telescope/telescope.nvim'
	local tb = require 'telescope.builtin'
	map('n', 'g/', tb.live_grep)
	tb.live_grep()
end)
map('n', 'm', function()
	Load_plugin 'niuiic/track.nvim'
	vim.keymap.del('n', 'm')
	vim.fn.feedkeys 'm'
end)
map('n', '<A-n>', function()
	Load_plugin 'SmiteshP/nvim-navbuddy'
	map('n', '<A-n>', vim.cmd.Navbuddy)
	vim.cmd.Navbuddy()
end)
local function Load_cmdln()
	require 'command'
	require 'fzf'
	Load_plugin 'stevearc/oil.nvim'
end
au({ 'CmdlineEnter' }, {
    once = true,
    callback = function()
		Load_cmdln()
    end
})
au({ 'InsertEnter', 'CmdlineEnter' }, {
	once = true,
	callback = function()
		Load_plugin 'altermo/ultimate-autopair.nvim'
	end
})
au({ 'CursorMoved' }, {
	once = true,
	callback = function()
		Load_plugin 'mini.indentscope'
		Load_plugin 'utilyre/sentiment.nvim'
		Load_plugin 'hadronized/hop.nvim'
		-- if not vim.g.neovide and vim.env.TERM ~= 'xterm-kitty' then
		-- 	Load_Plugin 'sphamba/smear-cursor.nvim'
		-- end
	end
})

local o = vim.opt
o.autoread = true
o.autowrite = true
o.complete = 'w,i,d,kspell'
o.completeopt = 'menuone,preinsert,noselect,popup,fuzzy'
o.cursorline = true
o.expandtab = true
o.foldmethod = 'manual'
o.fillchars = { stl = ' ', stlnc = ' ' }
o.gdefault = true
o.guicursor = 'n-v-c-sm:block,i-ci-ve:ver25-blinkwait1000-blinkoff300-blinkon1000,t:block-TermCursor'
o.hidden = true
o.ignorecase = true
o.hlsearch = false
o.incsearch = false
o.laststatus = 0
o.mouse = ''
o.number = false
o.paragraphs = ''
o.path = '.,,,**'
o.ruler = false
o.scrolloff = 10
o.shada = ''
o.shell = '/run/current-system/sw/bin/zsh'
o.shiftwidth = 4
o.showcmd = false
o.showmode = false
o.showtabline = 0
o.signcolumn = 'yes'
o.smartcase = true
o.smartindent = true
o.statusline = ' '
o.tabstop = 4
o.termguicolors = true
o.textwidth = 0
o.timeout = false
o.undodir = vim.fn.stdpath('data') .. '/undo'
o.undofile = true
o.wildmenu = true
o.wrap = false
vim.g.copilot_filetypes = { gitcommit = true, yaml = true, markdown = true }
if vim.g.neovide then
	vim.g.neovide_hide_mouse_when_typing = true
	vim.g.neovide_opacity = 1.0
	vim.g.transparency = 1.0
	vim.g.neovide_text_gamma = 0
	vim.g.neovide_text_contrast = 0.0
	vim.g.terminal_color_0  = '#171717' -- black
	vim.g.terminal_color_1  = '#d81765' -- normal red
	vim.g.terminal_color_2  = '#97d01a' -- normal green
	vim.g.terminal_color_3  = '#ffa800' -- normal yellow
	vim.g.terminal_color_4  = '#16b1fb' -- normal blue
	vim.g.terminal_color_5  = '#ff2491' -- normal magenta
	vim.g.terminal_color_6  = '#0fdcb6' -- normal cyan
	vim.g.terminal_color_7  = '#ebebeb' -- light gray
	vim.g.terminal_color_8  = '#88757c' -- dark gray
	vim.g.terminal_color_9  = '#ff0000' -- bright red
	vim.g.terminal_color_10 = '#76b639' -- bright green
	vim.g.terminal_color_11 = '#f7b125' -- bright yellow
	vim.g.terminal_color_12 = '#289cd5' -- bright blue
	vim.g.terminal_color_13 = '#ff2491' -- bright magenta
	vim.g.terminal_color_14 = '#0a9b81' -- bright cyan
	vim.g.terminal_color_15 = '#f8f8f8' -- white
end

local map = vim.keymap.set
local submode = require 'submode'
vim.g.mapleader = ' '
local function smart_gf()
	local fpath = vim.fn.expand('<cfile>')
	if fpath:sub(1, 8) == 'https://' then
		vim.cmd.term('w3m ' .. fpath)
		vim.cmd.startinsert()
	else
		vim.cmd.normal 'gF'
	end
end
-- consider indentation
local function smart_i()
	if vim.fn.getline('.'):match('^ *$') then
		vim.api.nvim_input '"_cc'
	else
		-- vim.api.nvim_input 'i' -- freeze
		vim.cmd.startinsert()
	end
end
map('n', '<BS>', '<C-b>')
map('n', '<Delete>', '<C-f>')
map('n', '<C-S-e>', '5<C-e>')
map('n', '<C-S-y>', '5<C-y>')
map('n', 'i', smart_i)
map('n', 'S', 'c^')
map('n', 'Q', 'ZZ', { noremap = true })
map('n', 'ZZ', function()
    vim.cmd.mksession(vim.env.HOME .. '/.cache/nvim/session.vim')
    vim.cmd.wqa()
end)
map('n', 'G', '')
map('n', 'GG', 'G')
map('n', 'gk', '25k')
map('n', 'gj', '25j')
map('n', 'gf', smart_gf)
map('n', 'gb', vim.cmd.bnext)
map('n', 'gB', vim.cmd.bprev)
map('n', '^n', function() vim.o.number = not vim.o.number end)
map('n', '^r', function() vim.o.relativenumber = not vim.o.relativenumber end)
map('n', '^s', function() vim.o.spell = not vim.o.spell end)
map('n', '<C-z>', ':w<CR><C-z>')
map('n', 'zS', vim.show_pos)
map({ 'n', 'v' }, 'q;', 'q:')
map({ 'n', 'o', 'v' }, 'K', '5k')
map({ 'n', 'o', 'v' }, 'J', '5j')
map({ 'n', 'v' }, 'x', '"_d')
map({ 'n', 'v' }, 'X', '"_D')
map({ 'n', 'v' }, ']]', '<C-]>')
map({ 'n', 'v' }, '<Leader>y', [["+y]])
map({ 'n', 'v' }, '<Leader>Y', [["+Y]])
map({ 'n', 'v' }, '<Leader>d', [["_d]])
map({ 'n', 'v', 'o' }, 'gl', '$l')
map({ 'n', 'v', 'o' }, 'gh', '^')
map({ 'n', 'v', 'o' }, ']b', '])')
map({ 'n', 'v', 'o' }, '[b', '[(')
map({ 'n', 'v', 'o' }, ']B', ']}')
map({ 'n', 'v', 'o' }, '[B', '[{')
map('i', '<Esc>', '<Right><Esc>')
map('v', '<C-k>', ":m '<-2<CR>gv=gv")
map('v', '<C-j>', ":m '>+1<CR>gv=gv")
map('v', 'v', '<C-v>')
map('v', 'aa', 'VggoG')
map('o', '.', 'i>')
map('o', 'iq', "i'")
map('o', 'iQ', 'i"')
map('o', 'aq', "a'")
map('o', 'aQ', 'a"')
map('o', 'i<Space>', 'iW')
map('o', 'a<Space>', 'aW')
map('t', '<C-\\>', '<C-\\><C-n>')
submode.set_submode_keymap('n', 'g', {
	{ key = 't' },
	{ key = 'T' },
	{ key = 'e' },
	{ key = 'E' },
	{ key = 'J' },
})
submode.set_submode_keymap('n', 'd', {
	{ key = 'h' },
	{ key = 'l' },
})
submode.set_submode_keymap('n', '<C-w>', {
	{ key = '>' },
	{ key = '<' },
	{ key = '+' },
	{ key = '-' },
	{ key = 'h' },
	{ key = 'j' },
	{ key = 'k' },
	{ key = 'l' },
})
submode.set_submode_keymap('n', 'z', {
	{ key = '<Space>', run_when = { entering = '<C-f>', repeating = '<C-f>' } },
	{ key = 'b',       run_when = { entering = '<C-b>', repeating = '<C-b>' } },
})
-- When pressed once, it does not move, but registers the word at the cursor position in the / register.
submode.set_submode_keymap('n', '*', {
	{ key = '*', run_when = { entering = '#*', repeating = '*' } },
})
submode.set_submode_keymap('n', '#', {
	{ key = '#', run_when = { entering = '*#', repeating = '#' } },
})
submode.acceleration_key('n', 'j')
submode.acceleration_key('n', 'k')
submode.acceleration_key('n', 'h')
submode.acceleration_key('n', 'l')
local function safe_cabbrev(lhs, rhs)
	vim.cmd('cabbrev <expr> ' ..
		lhs .. ' (getcmdtype() ==# ":" && getcmdline() ==# "' .. lhs .. '") ? "' .. rhs .. '" : "' .. lhs .. '"')
end
safe_cabbrev('r', 'lua require')
safe_cabbrev('l', 'lua')
vim.cmd 'cabbrev api vim.api'