Configurations for GNU Emacs

(eval-when-compile
  (el-clone :repo "kentaro/auto-save-buffers-enhanced"))

(with-delayed-execution
  (message "Install auto-save-buffers-enhanced...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/auto-save-buffers-enhanced"))

  (autoload-if-found '(auto-save-buffers-enhanced) "auto-save-buffers-enhanced" nil t)

  (with-eval-after-load 'auto-save-buffers-enhanced
    (setopt auto-save-buffers-enhanced-interval 10)))

(eval-when-compile
  (el-clone :repo "editorconfig/editorconfig-emacs"))

(with-delayed-execution
  (message "Install editorconfig...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/editorconfig-emacs"))

  (autoload-if-found '(editorconfig-mode) "editorconfig" nil t)

  (editorconfig-mode 1))

(eval-when-compile
  (el-clone :repo "Fanael/persistent-scratch"))

(with-delayed-execution
  (message "Install persistent-scratch...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/persistent-scratch"))

  (autoload-if-found '(persistent-scratch-setup-default) "persistent-scratch" nil t)

  ;; (persistent-scratch-setup-default)

  (with-eval-after-load 'persistent-scratch
    (setopt persistent-scratch-autosave-interval 100)))

(eval-when-compile
  (el-clone :repo "emacsorphanage/popwin"))

(with-delayed-execution
  (message "Install popwin...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/popwin"))

  (autoload-if-found '(popwin-mode) "popwin" nil t)

  (popwin-mode 1))

(with-delayed-execution
  (message "Install whitespace...")
  (when (autoload-if-found '(global-whitespace-mode) "whitespace" nil t)
    (if window-system
        (global-whitespace-mode 1)))
  (with-eval-after-load 'whitespace
    (setopt whitespace-style '(face tabs tab-mark spaces space-mark))
    (setopt whitespace-display-mappings '((space-mark ?\u3000 [?\u25a1])
                                        (tab-mark ?\t [?\xBB ?\t] [?\\ ?\t])))))

(eval-when-compile
  (el-clone :repo "flycheck/flycheck"))

(with-delayed-execution
  (message "Install flycheck...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/flycheck"))

  (autoload-if-found '(flycheck-mode flycheck-define-checker) "flycheck" nil t))

(with-delayed-execution
  (flycheck-define-checker textlint
    "A linter for prose."
    :command ("npx" "textlint" "--format" "unix" source-inplace)
    :error-patterns
    ((warning line-start (file-name) ":" line ":" column ": "
              (id (one-or-more (not (any " "))))
              (message (one-or-more not-newline)
                       (zero-or-more "\n" (any " ") (one-or-more not-newline)))
              line-end))
    :modes (org-mode))
  (with-eval-after-load 'flycheck
    (add-to-list 'flycheck-checkers 'textlint)))

(eval-when-compile
  (el-clone :repo "emacs-elsa/flycheck-elsa"))

(with-delayed-execution
  (message "Install flycheck-elsa...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/flycheck-elsa"))

  (autoload-if-found '(flycheck-elsa-setup) "flycheck-elsa" nil t)

  (with-eval-after-load 'elisp-mode
    (add-hook 'emacs-lisp-mode-hook #'flycheck-elsa-setup)))

(eval-when-compile
  (el-clone :repo "nbfalcon/flycheck-projectile"))

(with-delayed-execution
  (message "Install flycheck-projectile...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/flycheck-projectile"))
  (autoload-if-found '(flycheck-projectile-list-errors) "flycheck-projectile" nil t))

(eval-when-compile
  (el-clone :repo "ahungry/md4rd"))

(with-delayed-execution
  (message "Install md4rd...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/md4rd"))

  (autoload-if-found '(md4rd
                       md4rd-login
                       md4rd-visit
                       md4rd-widget-expand-all
                       md4rd-widget-collapse-all
                       md4rd-reply
                       md4rd-upvote
                       md4rd-downvote
                       md4rd-widget-toggle-line
                       md4rd-refresh-login
                       md4rd-indent-all-the-lines) "md4rd" nil t)

  (with-eval-after-load 'md4rd
    (add-hook 'md4rd-mode-hook #'md4rd-indent-all-the-lines)
    (run-with-timer 0 3540 #'md4rd-refresh-login)

    ;; config
    (setopt md4rd-subs-active '(emacs lisp+Common_Lisp prolog clojure))
    ;; (setopt md4rd--oauth-access-token "your-access-token-here")
    ;; (setopt md4rd--oauth-refresh-token "your-refresh-token-here")

    ;; keymap
    (define-key md4rd-mode-map (kbd "u") 'tree-mode-goto-parent)
    (define-key md4rd-mode-map (kbd "o") 'md4rd-open)
    (define-key md4rd-mode-map (kbd "v") 'md4rd-visit)
    (define-key md4rd-mode-map (kbd "e") 'tree-mode-toggle-expand)
    (define-key md4rd-mode-map (kbd "E") 'md4rd-widget-expand-all)
    (define-key md4rd-mode-map (kbd "C") 'md4rd-widget-collapse-all)
    (define-key md4rd-mode-map (kbd "n") 'widget-forward)
    (define-key md4rd-mode-map (kbd "j") 'widget-forward)
    (define-key md4rd-mode-map (kbd "h") 'backward-button)
    (define-key md4rd-mode-map (kbd "p") 'widget-backward)
    (define-key md4rd-mode-map (kbd "k") 'widget-backward)
    (define-key md4rd-mode-map (kbd "l") 'forward-button)
    (define-key md4rd-mode-map (kbd "q") 'kill-current-buffer)
    (define-key md4rd-mode-map (kbd "r") 'md4rd-reply)
    (define-key md4rd-mode-map (kbd "u") 'md4rd-upvote)
    (define-key md4rd-mode-map (kbd "d") 'md4rd-downvote)
    (define-key md4rd-mode-map (kbd "t") 'md4rd-widget-toggle-line)))

(with-delayed-execution
  (message "Install ansi-color...")
  (autoload 'ansi-color-for-comint-mode-on "ansi-color" "Set `ansi-color-for-comint-mode' to t." t)
  (autoload-if-found '(ansi-color-for-comint-mode-on) "ansi-color" nil t)

  (with-eval-after-load 'shell-mode
    (add-hook 'shell-mode-hook #'ansi-color-for-comint-mode-on))

  (with-eval-after-load 'compile
    (add-hook 'compilation-filter-hook #'(lambda ()
                                           (ansi-color-apply-on-region (point-min) (point-max))))))

(eval-when-compile
  (el-clone :repo "DarthFennec/highlight-indent-guides"))

(with-delayed-execution
  (message "Install highlight-indent-guides...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/highlight-indent-guides"))

  (autoload-if-found '(highlight-indent-guides-mode) "highlight-indent-guides" nil t)

  (with-eval-after-load 'yaml-mode
    (add-hook 'yaml-mode-hook 'highlight-indent-guides-mode))

  (with-eval-after-load 'highlight-indent-guides
    (setopt highlight-indent-guides-responsive 'stack)
    (setopt highlight-indent-guides-method 'bitmap)))

(eval-when-compile
  (el-clone :repo "tarsius/hl-todo"))

(with-delayed-execution
  (message "Install hl-todo...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/hl-todo"))

  (autoload-if-found '(global-hl-todo-mode) "hl-todo" nil t)

  (global-hl-todo-mode)

  (with-eval-after-load 'hl-todo
    (setopt hl-todo-keyword-faces
          '(("HOLD" . "#d0bf8f")
            ("TODO" . "#cc9393")
            ("NOW" . "#dca3a3")
            ("SOMEDAY" . "#dc8cc3")
            ("WAIT" . "#7cb8bb")
            ("DONE" . "#afd8af")
            ("FIXME" . "#cc9393")))))

(eval-when-compile
  (el-clone :repo "atomontage/xterm-color"))

(with-delayed-execution
  (message "Install xterm-color...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/xterm-color"))

  (autoload-if-found '(xterm-color-filter) "xterm-color" nil t)

  (setenv "TERM" "xterm-256color")

  (with-eval-after-load 'xterm-color
    (setopt xterm-color-preserve-properties t)))

(eval-when-compile
  (el-clone :repo "DarwinAwardWinner/amx"))

(with-delayed-execution-priority-high
  (message "Install amx...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/amx"))

  (with-eval-after-load 'amx
    (setopt amx-history-length 100)))

(eval-when-compile
  (el-clone :repo "minad/corfu"))

(with-delayed-execution
  (message "Install corfu...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/corfu"))
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/corfu/extensions"))

  (autoload-if-found '(global-corfu-mode) "corfu" nil t)

  (global-corfu-mode)

  (with-eval-after-load 'corfu
    (setopt corfu-auto t)
    (setopt corfu-auto-delay 0.2)
    (setopt corfu-cycle t)
    (setopt corfu-on-exact-match nil))

  (with-eval-after-load 'indent
    (setopt tab-always-indent 'complete)))

(eval-when-compile
  (el-clone :repo "minad/cape"))

(with-delayed-execution
  (message "Install cape...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/cape"))

  (autoload-if-found '(cape-file
                       cape-dabbrev
                       cape-elisp-block
                       cape-history
                       cape-keyword) "cape" nil t)

  (with-eval-after-load 'minibuffer
    (add-to-list 'completion-at-point-functions #'cape-dabbrev)
    (add-to-list 'completion-at-point-functions #'cape-file)
    (add-to-list 'completion-at-point-functions #'cape-elisp-block)
    (add-to-list 'completion-at-point-functions #'cape-history)))

(eval-when-compile
  (el-clone :repo "radian-software/prescient.el"))

(with-delayed-execution
  (message "Install prescient...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/prescient"))

  (autoload-if-found '(prescient-persist-mode) "prescient" nil t)

  (prescient-persist-mode)

  (with-eval-after-load 'prescient
    (setopt prescient-aggressive-file-save t)))

(eval-when-compile
  (el-clone :repo "jdtsmith/kind-icon"))

(with-delayed-execution
  (message "Install kind-icon...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/kind-icon"))

  (autoload-if-found '(kind-icon-margin-formatter) "kind-icon" nil t)

  (with-eval-after-load 'corfu
    (add-to-list 'corfu-margin-formatters #'kind-icon-margin-formatter)))

(eval-when-compile
  (el-clone :repo "abo-abo/avy"))

(with-delayed-execution
  (message "Install avy...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/avy"))

  (autoload-if-found '(avy-goto-word-1) "avy" nil t)

  (keymap-global-set "C-:" #'avy-goto-word-1)

  (with-eval-after-load 'avy
    (setopt avy-all-windows nil)
    (setopt avy-background t)))

(eval-when-compile
  (el-clone :repo "cute-jumper/avy-zap"))

(with-delayed-execution
  (message "Install avy-zap...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/avy-zap"))

  (autoload-if-found '(avy-zap-up-to-char-dwim) "avy-zap" nil t)

  (keymap-global-set "M-z" 'avy-zap-up-to-char-dwim))

(eval-when-compile
  (el-clone :repo "magnars/expand-region.el"))

(with-delayed-execution
  (message "Install expand-region...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/expand-region"))

  (autoload-if-found '(er/expand-region) "expand-region" nil t)

  (transient-mark-mode)

  (keymap-global-set "C-M-@" 'er/expand-region))

(eval-when-compile
  (el-clone :repo "magnars/multiple-cursors.el"))

(with-delayed-execution
  (message "Install multiple-cursors...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/multiple-cursors"))

  (autoload-if-found '(mc/mark-next-like-this mc/mark-previous-like-this mc/mark-all-like-this) "multiple-cursors" nil t)

  (keymap-global-set "C->" #'mc/mark-next-like-this)
  (keymap-global-set "C-<" #'mc/mark-previous-like-this)
  (keymap-global-set "C-c C-<" #'mc/mark-all-like-this))

(with-delayed-execution
  (message "Install subword...")
  (autoload-if-found '(my/delete-forward-block) "subword" nil t)

  (keymap-global-set "M-d" #'my/delete-forward-block)

  (defun my/delete-forward-block ()
    (interactive)
    (if (eobp)
        (message "End of buffer")
      (let* ((syntax-move-point
              (save-excursion
                (skip-syntax-forward (string (char-syntax (char-after))))
                (point)))
             (subword-move-point
              (save-excursion
                (subword-forward)
                (point))))
        (kill-region (point) (min syntax-move-point subword-move-point))))))

(eval-when-compile
  (el-clone :repo "abo-abo/define-word"))

(with-delayed-execution
  (message "Install define-word...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/define-word"))

  (defun my/define-word ()
    (interactive)
    (if (use-region-p)
        (call-interactively #'define-word-at-point)
      (call-interactively #'define-word)))

  (with-eval-after-load 'define-word
    (setopt define-word-displayfn-alist
          '((wordnik . takeokunn/define-word--display-in-buffer)
            (openthesaurus . takeokunn/define-word--display-in-buffer)
            (webster . takeokunn/define-word--display-in-buffer)
            (weblio . takeokunn/define-word--display-in-buffer)))))

(eval-when-compile
  (el-clone :repo "Fuco1/dired-hacks"))

(with-delayed-execution
  (message "Install dired...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/dired-hacks"))

  (with-eval-after-load 'dired
    ;; config
    (setopt dired-dwim-target nil)
    (setopt dired-hide-details-hide-symlink-targets nil)
    (setopt dired-listing-switches "-alh")
    (setopt dired-recursive-copies 'always)
    (setopt dired-use-ls-dired nil)

    ;; hook
    (add-hook 'dired-mode-hook #'(lambda () (display-line-numbers-mode -1)))))

(with-delayed-execution
  (message "Install dired-collapse...")

  (autoload-if-found '(dired-collapse-mode) "dired-collapse" nil t)

  (with-eval-after-load 'dired
    (add-hook 'dired-mode #'dired-collapse-mode)))

(with-delayed-execution
  (message "Install dired-filter...")
  (autoload-if-found '(dired-filter-mode) "dired-filter" nil t)
  (with-eval-after-load 'dired
    (add-hook 'dired-mode #'dired-filter-mode)))

(with-delayed-execution
  (message "Install dired-narrow...")

  (autoload-if-found '(dired-narrow-mode) "dired-narrow" nil t)

  (with-eval-after-load 'dired
    (add-hook 'dired-mode-hook #'dired-narrow-mode)))

(with-delayed-execution
  (message "Install dired-open...")

  (autoload-if-found '(dired-open-file) "dired-open" nil t)

  (with-eval-after-load 'dired
    (define-key dired-mode-map [remap dired-find-file] #'dired-open-file)))

(with-delayed-execution
  (message "Install dired-ranger...")
  (autoload-if-found '() "dired-ranger" nil t))

(eval-when-compile
  (el-clone :fetcher "gitlab"
            :repo "xuhdev/dired-quick-sort"))

(with-delayed-execution
  (message "Install dired-quick-sort...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/dired-quick-sort"))

  (autoload-if-found '(dired-quick-sort-setup) "dired-quick-sort" nil t)

  (with-eval-after-load 'dired
    (add-hook 'dired-mode-hook #'dired-quick-sort-setup)))

(with-delayed-execution
  (message "Install dired-subtree...")
  (autoload-if-found '(dired-subtree-apply-filter) "dired-subtree" nil t))

(eval-when-compile
  (el-clone :repo "purcell/diredfl"))

(with-delayed-execution
  (message "Install diredfl...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/diredfl"))
  (autoload-if-found '(diredfl-global-mode) "diredfl" nil t)
  (diredfl-global-mode))

(with-delayed-execution
  (message "Install eww...")

  (defun my/eww-rename-buffer ()
    "Rename the name of current EWW buffer."
    (let* ((title (plist-get eww-data :title))
           (url (file-name-base (eww-current-url)))
           (buffer-name (or (if (and title (> (length title) 0))
                                title
                              nil)
                            url "")))
      (rename-buffer (format "eww: %s" buffer-name) t)))

  ;; config
  (with-eval-after-load 'eww
    (setopt eww-header-line-format nil)
    (setopt eww-search-prefix "http://www.google.co.jp/search?q="))

  ;; keybind
  (with-eval-after-load 'eww
    (define-key eww-mode-map (kbd "C") #'eww-set-character-encoding)
    (define-key eww-mode-map (kbd "C-j") #'eww-follow-link)
    (define-key eww-mode-map (kbd "T") #'eww-goto-title-heading)
    (define-key eww-mode-map (kbd "T") #'eww-goto-title-heading))

  ;; hooks
  (with-eval-after-load 'eww
    (add-hook 'eww-after-render #'my/eww-rename-buffer)))

(eval-when-compile
  (el-clone :repo "m00natic/eww-lnum"))

(with-delayed-execution
  (message "Install eww-lnum...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/eww-lnum"))

  (autoload-if-found '(eww-lnum-follow eww-lnum-universal) "eww-lnum" nil t)

  (with-eval-after-load 'eww
    (define-key eww-mode-map "f" #'eww-lnum-follow)
    (define-key eww-mode-map "F" #'eww-lnum-universal)))

(with-delayed-execution
  (message "Install recentf...")
  (autoload-if-found '(recentf-mode) "recentf" nil t)
  (recentf-mode 1)
  (with-eval-after-load 'recentf
    (setopt recentf-max-menu-items 10000)
    (setopt recentf-max-saved-items 10000)
    (setopt recentf-auto-cleanup 'never)
    (setopt recentf-save-file  "~/.emacs.d/.recentf")
    (setopt recentf-exclude '(".recentf" "\\.gpg\\"))))

(eval-when-compile
  (el-clone :repo "rubikitch/open-junk-file"))

(with-delayed-execution
  (message "Install open-junk-file...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/open-junk-file"))

  (autoload-if-found '(open-junk-file) "open-junk-file" nil t)

  (keymap-global-set "C-x j" #'open-junk-file)

  (with-eval-after-load 'open-junk-file
    (setopt open-junk-file-format "~/.emacs.d/.junk/%Y-%m-%d-%H%M%S.")))

(eval-when-compile
  (el-clone :repo "m00natic/vlfi"))

(with-delayed-execution
  (message "Install vlfi...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/vlfi"))

  (autoload-if-found '(vlf-disable-for-function) "vlf-setup" t)

  (vlf-disable-for-function tags-verify-table "etags")
  (vlf-disable-for-function tag-find-file-of-tag-noselect "etags")
  (vlf-disable-for-function helm-etags-create-buffer "helm-tags")

  (with-eval-after-load 'dired
    (define-key dired-mode-map (kbd "V") #'dired-vlf)))

(eval-when-compile
  (el-clone :repo "Lindydancer/font-lock-studio"))

(with-delayed-execution
  (message "Install font-lock-studio...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/font-lock-studio"))

  (autoload-if-found '(font-lock-studio) "font-lock-studio" nil t))

(eval-when-compile
  (el-clone :repo "emacsmirror/gcmh"))

(with-delayed-execution
  (message "Install gcmh...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/gcmh"))

  (autoload-if-found '(gcmh-mode) "gcmh" nil t)

  (gcmh-mode)

  (defvar my/gcmh-status nil)

  (advice-add #'garbage-collect
              :before
              (defun my/gcmh-log-start (&rest _)
                (when gcmh-verbose
                  (setopt my/gcmh-status "Running GC..."))))

  (advice-add #'gcmh-message
              :override
              (defun my/gcmh-message (format-string &rest args)
                (setopt my/gcmh-status
                      (apply #'format-message format-string args))
                (run-with-timer 2 nil
                                (lambda ()
                                  (setopt my/gcmh-status nil)))))

  (with-eval-after-load 'gcmh
    ;; config
    (setopt gcmh-verbose t)))

(eval-when-compile
  (el-clone :repo "magit/transient"
            :load-paths `(,(locate-user-emacs-file "el-clone/transient/lisp")))
  (el-clone :repo "magit/ghub"
            :load-paths `(,(locate-user-emacs-file "el-clone/ghub/lisp")))
  (el-clone :repo "magit/magit-popup")
  (el-clone :repo "magit/with-editor"
            :load-paths `(,(locate-user-emacs-file "el-clone/with-editor/lisp")))
  (el-clone :repo "magit/magit"
            :load-paths `(,(locate-user-emacs-file "el-clone/magit/lisp"))))

(with-delayed-execution-priority-high
  (message "Install magit...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/transient/lisp"))
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/ghub/lisp"))
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/magit-popup"))
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/with-editor/lisp"))
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/magit/lisp"))

  (autoload-if-found '(global-git-commit-mode) "git-commit" nil t)
  (autoload-if-found '(magit-status magit-blame) "magit")

  (global-git-commit-mode)

  (defun my/magit-status ()
    (interactive)
    (let ((default-directory (locate-dominating-file default-directory ".git")))
      (magit-status)))

  (keymap-global-set "C-x g" #'my/magit-status)
  (keymap-global-set "C-x G" #'magit-blame)

  (with-eval-after-load 'magit
    (setopt magit-refresh-status-buffer nil))

  (with-eval-after-load 'magit-status
    ;; config
    (setq magit-status-sections-hook
          '(magit-insert-status-headers
            ;; magit-insert-merge-log
            ;; magit-insert-rebase-sequence
            ;; magit-insert-am-sequence
            ;; magit-insert-sequencer-sequence
            ;; magit-insert-bisect-output
            ;; magit-insert-bisect-rest
            ;; magit-insert-bisect-log
            magit-insert-untracked-files
            magit-insert-unstaged-changes
            magit-insert-staged-changes
            ;; magit-insert-stashes
            magit-insert-unpushed-to-pushremote
            magit-insert-unpushed-to-upstream-or-recent
            magit-insert-unpulled-from-pushremote
            magit-insert-unpulled-from-upstream))


    ;; keybind
    (define-key magit-status-mode-map (kbd "C-j") #'magit-visit-thing))

  (with-eval-after-load 'magit-log
    (define-key magit-log-mode-map (kbd "C-j") #'magit-visit-thing))

  (with-eval-after-load 'git-commit
    (define-key git-commit-mode-map (kbd "C-h") #'delete-backward-char)))

(eval-when-compile
  (el-clone :repo "gekoke/magit-file-icons"))

(with-delayed-execution
  (message "Install magit-file-icons...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/magit-file-icons"))

  (autoload-if-found '(magit-file-icons-mode) "magit-file-icons" nil t)

  ;; (with-eval-after-load 'magit
  ;;   (add-hook 'magit-mode-hook #'magit-file-icons-mode))
  )

(eval-when-compile
  (el-clone :repo "douo/magit-gptcommit"))

(with-delayed-execution
  (message "Install magit-gptcommit...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/magit-gptcommit"))
  (autoload-if-found '(magit-gptcommit-status-buffer-setup
                       magit-gptcommit-mode
                       magit-gptcommit-commit-accept) "magit-gptcommit" nil t)

  ;; (magit-gptcommit-status-buffer-setup)

  (with-eval-after-load 'magit
    (add-hook 'magit-mode #'magit-gptcommit-mode))

  (with-eval-after-load 'git-commit
    (define-key git-commit-mode-map (kbd "C-c C-g") #'magit-gptcommit-commit-accept)))

(eval-when-compile
  (el-clone :repo "magit/forge"
            :load-paths `(,(locate-user-emacs-file "el-clone/forge/lisp"))))

(with-delayed-execution
  (message "Install magit-forge...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/forge/lisp"))

  ;; (add-hook 'magit-mode-hook #'(lambda () (require 'forge)))
  )

(eval-when-compile
  (el-clone :repo "emacsorphanage/git-gutter"))

(with-delayed-execution
  (message "Install git-gutter...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/git-gutter"))

  (autoload-if-found '(git-gutter-mode) "git-gutter" nil t)

  (with-eval-after-load 'git-gutter
    ;; (add-hook 'prog-mode-hook #'git-gutter-mode)
    (setopt git-gutter:update-hooks '(after-save-hook after-revert-hook))))

(eval-when-compile
  (el-clone :repo "emacsorphanage/git-gutter-fringe"))

(with-delayed-execution
  (message "Install git-gutter-fringe...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/git-gutter-fringe"))

  (autoload-if-found '(git-gutter-fr:init
                       git-gutter-fr:view-diff-infos
                       git-gutter-fr:clear) "git-gutter-fringe" nil t)

  (with-eval-after-load 'git-gutter
    (setopt git-gutter-fr:side 'right-fringe)
    (setopt git-gutter:window-width -1)
    (setopt git-gutter:init-function #'git-gutter-fr:init)
    (setopt git-gutter:view-diff-function #'git-gutter-fr:view-diff-infos)
    (setopt git-gutter:clear-function #'git-gutter-fr:clear)))

(eval-when-compile
  (el-clone :repo "emacsmirror/git-timemachine"))

(with-delayed-execution
  (message "Install git-timemachine...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/git-timemachine"))

  (autoload-if-found '(git-timemachine) "git-timemachine" nil t))

(eval-when-compile
  (el-clone :repo "defunkt/gist.el"))

(with-delayed-execution
  (message "Install gist...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/gist"))

  (autoload-if-found '(gist-mode) "gist" nil t))

(eval-when-compile
  (el-clone :repo "Artawower/blamer.el"))

(with-delayed-execution
  (message "Install blamer...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/blamer"))

  (autoload-if-found '(blamer-mode) "blamer" nil t))

(eval-when-compile
  (el-clone :repo "ryuslash/git-auto-commit-mode"))

(with-delayed-execution
  (message "Install git-auto-commit-mode...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/git-auto-commit-mode"))

  (autoload-if-found '(git-auto-commit-mode) "git-auto-commit-mode" nil t)

  (with-eval-after-load 'git-auto-commit-mode
    (setopt gac-automatically-push-p t)
    (setopt gac-silent-message-p t)
    (setopt gac-debounce-interval (* 60 60 3))
    (setopt gac-default-message "Update")))

(eval-when-compile
  (el-clone :repo "Malabarba/emacs-google-this"))

(with-delayed-execution
  (message "Install google-this...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/emacs-google-this"))

  (autoload-if-found '(google-this) "google-this" nil t))

(eval-when-compile
  (el-clone :repo "zonuexe/google-translate"))

(with-delayed-execution
  (message "Install google-translate...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/google-translate"))

  (autoload-if-found '(google-translate-at-point) "google-translate" nil t))

(with-delayed-execution
  (message "Install epa-file...")
  (autoload-if-found '(epa-file-enable) "epa-file" nil t)

  (epa-file-enable)

  (with-eval-after-load 'epa-file
    (setopt epa-file-encrypt-to '("bararararatty@gmail.com"))
    (setopt epa-file-select-keys 'silent)
    (setopt epa-file-cache-passphrase-for-symmetric-encryption t)
    (setopt epg-pinentry-mode 'loopback)

    (fset 'epg-wait-for-status 'ignore)))

(eval-when-compile
  (el-clone :repo "ueno/pinentry-el"))

(with-delayed-execution
  (message "Install pinentry...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/pinentry-el"))

  (autoload-if-found '(pinentry-start) "pinentry" nil t)
  (when-guix
   (pinentry-start)))

(eval-when-compile
  (el-clone :repo "Wilfred/helpful"))

(with-delayed-execution
  (message "Install helpful...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/helpful"))

  (autoload-if-found '(helpful-callable
                       helpful-function
                       helpful-macro
                       helpful-command
                       helpful-key
                       helpful-variable
                       helpful-at-point) "helpful" nil t)
  ;; keybinds
  (keymap-global-set "C-h f" #'helpful-callable)
  (keymap-global-set "C-h v" #'helpful-variable)
  (keymap-global-set "C-h k" #'helpful-key)
  (keymap-global-set "C-c C-d" #'helpful-at-point)
  (keymap-global-set "C-h F" #'helpful-function)
  (keymap-global-set "C-h C" #'helpful-command))

(eval-when-compile
  (el-clone :repo "skk-dev/ddskk"))

(with-delayed-execution-priority-high
  (message "Install ddskk...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/ddskk"))

  (autoload-if-found '(skk-mode) "skk-autoloads" nil t)

  (keymap-global-set "C-x C-j" #'skk-mode)

  (defun my/skk-C-j-key (arg)
    (interactive "P")
    (cond
     ((and (null (skk-in-minibuffer-p))
           (null skk-henkan-mode))
      (skk-emulate-original-map arg))
     (t
      (skk-kakutei arg))))

  (with-eval-after-load 'skk
    ;; config
    (setopt skk-preload t)
    (setopt default-input-method "japanese-skk"))

  (with-eval-after-load 'skk-vars
    ;; use skkserv
    (when-darwin
     (setopt skk-server-host "localhost")
     (setopt skk-server-portnum 1178))

    ;; guix
    (when-guix
     (setopt skk-user-directory "~/.my-skk-jisyo"))

    (setopt skk-byte-compile-init-file t)
    (setopt skk-isearch-mode-enable 'always)
    (setopt skk-egg-like-newline t)
    (setopt skk-show-annotation nil)
    (setopt skk-auto-insert-paren t)

    ;; azik
    (setopt skk-use-azik t)
    (setopt skk-azik-keyboard-type 'jp106)

    ;; ref: https://github.com/skk-dev/ddskk/blob/master/etc/dot.skk#L752-L768
    (add-to-list 'skk-rom-kana-rule-list '(skk-kakutei-key nil my/skk-C-j-key))))

(eval-when-compile
  (el-clone :repo "conao3/ddskk-posframe.el"))

(with-delayed-execution
  (message "Install ddskk-posframe...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/ddskk-posframe"))

  (autoload-if-found '(ddskk-posframe-mode) "ddskk-posframe" nil t)

  (with-eval-after-load 'skk
    (add-hook 'skk-mode-hook #'ddskk-posframe-mode)))

(eval-when-compile
  (el-clone :repo "dieggsy/emacs-hacker-typer"))

(with-delayed-execution
  (message "Install hacker-typer...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/emacs-hacker-typer"))

  (autoload-if-found '(hacker-typer) "hacker-typer" nil t))

(eval-when-compile
  (el-clone :repo "elizagamedev/power-mode.el"))

(with-delayed-execution
  (message "Install power-mode...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/power-mode"))

  (autoload-if-found '(power-mode) "power-mode" nil t))

(eval-when-compile
  (el-clone :repo "yewton/sudden-death.el"))

(with-delayed-execution
  (message "Install sudden-death...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/sudden-death"))

  (autoload-if-found '(sudden-death) "sudden-death" nil t))

(eval-when-compile
  (el-clone :repo "bkaestner/redacted.el"))

(with-delayed-execution
  (message "Install redacted...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/redacted"))

  (autoload-if-found '(redacted-mode) "redacted" nil t)

  (defun my/redacted-mode ()
    (interactive)
    (read-only-mode (if redacted-mode -1 1))
    (redacted-mode (if redacted-mode -1 1))))

(eval-when-compile
  (el-clone :repo "jschaf/emacs-lorem-ipsum"))

(with-delayed-execution
  (message "Install lorem-ipsum...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/emacs-lorem-ipsum"))

  (autoload-if-found '(lorem-ipsum-insert-sentences
                       lorem-ipsum-insert-paragraphs
                       lorem-ipsum-insert-list) "lorem-ipsum" nil t)

  (keymap-global-set "C-c C-l s" #'lorem-ipsum-insert-sentences)
  (keymap-global-set "C-c C-l p" #'lorem-ipsum-insert-paragraphs)
  (keymap-global-set "C-c C-l l" #'lorem-ipsum-insert-list))

(eval-when-compile
  (el-clone :repo "emacsorphanage/key-chord"))

(with-delayed-execution
  (message "Install key-chord...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/key-chord"))

  (autoload-if-found '(key-chord-mode key-chord-define-global) "key-chord" nil t)
  (key-chord-mode 1)

  ;; for global
  (key-chord-define-global "fj" #'view-mode)
  (key-chord-define-global "jf" #'view-mode))

(eval-when-compile
  (el-clone :repo "uk-ar/key-combo"))

(with-delayed-execution
  (message "Install key-combo...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/key-combo"))

  (autoload-if-found '(key-combo-mode key-combo-define-local) "key-combo" nil t)

  ;; for php-mode
  (with-eval-after-load 'php-mode
    ;; (add-hook 'php-mode-hook
    ;;           #'(lambda ()
    ;;               (key-combo-mode)
    ;;               (when (window-system)
    ;;                 (key-combo-define-local (kbd ",>") " => "))
    ;;               ;; (key-combo-define-local (kbd "+") '("+" " + " "++" " ++ "))
    ;;               ;; (key-combo-define-local (kbd "-") '("-" " - " "--" " -- "))
    ;;               ;; (key-combo-define-local (kbd "*") '("*" "**" " * "))
    ;;               ;; (key-combo-define-local (kbd "=") '("=" " = " "==" "==="))
    ;;               ))
    )

  ;; for typescript-tsx-mode
  (with-eval-after-load 'typescript-tsx-mode
    (add-hook 'typescript-tsx-mode
              #'(lambda ()
                  (key-combo-mode)
                  (key-combo-define-local (kbd "</") #'web-mode-element-close)))))

(eval-when-compile
  (el-clone :repo "justbur/emacs-which-key"))

(with-delayed-execution
  (message "Install which-key...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/emacs-which-key"))

  (autoload-if-found '(which-key-mode) "which-key" nil t)

  (which-key-mode))

(eval-when-compile
  (el-clone :repo "emacs-jp/dmacro"))

(with-delayed-execution
  (message "Install dmacro...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/dmacro"))

  (autoload-if-found '(global-dmacro-mode) "dmacro" nil t)

  (global-dmacro-mode))

(eval-when-compile
  (el-clone :repo "emacsorphanage/god-mode"))

(with-delayed-execution
  (message "Install god-mode...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/god-mode"))
  (autoload-if-found '(god-mode) "god-mode" nil t))

(with-delayed-execution
  (message "Install eglot...")

  (autoload-if-found '(eglot) "eglot" nil t)

  (with-eval-after-load 'eglot
    ;; config
    (setopt eglot-events-buffer-size nil)
    (setopt eglot-autoshutdown t)
    (setopt eglot-extend-to-xref t)

    ;; language server
    ;; (add-to-list 'eglot-server-programs '(php-mode . ("intelephense" "--stdio")))
    (add-to-list 'eglot-server-programs '(clojure-mode clojurescript-mode clojurec-mode
                                                       . ("/Users/take/.emacs.d/.cache/lsp/clojure/clojure-lsp"
                                                          "listen" "--verbose")))))

(eval-when-compile
  (el-clone :repo "emacs-lsp/lsp-mode"
            :load-paths `(,(locate-user-emacs-file "el-clone/lsp-mode/clients"))))

(with-delayed-execution
  (message "Install lsp-mode...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/lsp-mode"))
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/lsp-mode/clients"))

  (autoload-if-found '(lsp lsp-deferred lsp-org lsp-register-client make-lsp-client) "lsp-mode" nil t)
  (autoload-if-found '(lsp-lens-mode lsp-lens-refresh lsp-lens--enable) "lsp-lens" nil t)
  (autoload-if-found '(lsp-modeline-workspace-status-mode) "lsp-modeline" nil t)
  (autoload-if-found '(lsp-headerline-breadcrumb-mode) "lsp-headerline" nil t)
  (autoload-if-found '(lsp-diagnostics-mode) "lsp-diagnostics" nil t)

  (advice-add 'lsp-rename :before #'(lambda (&rest _) (remove-hook 'find-file-hooks #'view-mode)))
  (advice-add 'lsp-rename :after #'(lambda (&rest _) (add-hook 'find-file-hooks #'view-mode)))

  (with-eval-after-load 'lsp-mode
    (add-to-list 'lsp-language-id-configuration '("php-ts-mode" . "php"))

    ;; ignore path
    (add-to-list 'lsp-file-watch-ignored-directories "[/\\\\]vendor")
    (add-to-list 'lsp-file-watch-ignored-directories "[/\\\\]storage")
    (add-to-list 'lsp-file-watch-ignored-directories "[/\\\\]docs")
    (add-to-list 'lsp-file-watch-ignored-directories "[/\\\\]target")
    (add-to-list 'lsp-file-watch-ignored-directories "[/\\\\].calva")
    (add-to-list 'lsp-file-watch-ignored-directories "[/\\\\].clj-kondo")
    (add-to-list 'lsp-file-watch-ignored-directories "[/\\\\].direnv")

    ;; enable flycheck
    (add-hook 'lsp-mode-hook #'flycheck-mode)

    ;; enable diagnostics
    (add-hook 'lsp-configure-hook #'lsp-diagnostics-mode)

    ;; config
    (setopt lsp-idle-delay 0.8)
    (setopt lsp-enable-links nil)
    (setopt lsp-log-io nil)
    (setopt lsp-file-watch-threshold 20000))

  (with-eval-after-load 'lsp-diagnostics
    (setopt lsp-diagnostics-flycheck-default-level 'info))

  (with-eval-after-load 'lsp-completion
    (setopt lsp-completion-no-cache t)
    (setopt lsp-prefer-capf t))

  (with-eval-after-load 'lsp-php
    ;; for intelephense
    (setopt lsp-intelephense-telemetry-enabled t)
    (setopt lsp-intelephense-files-exclude ["**/.git/**" "**/.svn/**" "**/.hg/**" "**/CVS/**" "**/.DS_Store/**"
                                            "**/node_modules/**" "**/bower_components/**" "**/vendor/**/{Test,test,Tests,tests}/**"
                                            "**/.direnv/**"]))

  (with-eval-after-load 'lsp-javascript
    ;; for typescript-language-server
    (setopt lsp-clients-typescript-log-verbosity "info")
    (setopt lsp-typescript-references-code-lens-enabled t)
    (setopt lsp-typescript-implementations-code-lens-enabled t)
    (setopt lsp-javascript-display-return-type-hints t)
    (setopt lsp-javascript-display-parameter-type-hints t)
    (setopt lsp-javascript-display-parameter-name-hints-when-argument-matches-name t)
    (setopt lsp-javascript-display-property-declaration-type-hints t)
    (setopt lsp-javascript-display-variable-type-hints t))

  (with-eval-after-load 'lsp-completion
    (setopt lsp-completion-provider :none))

  (with-eval-after-load 'lsp-ruby
    (setopt lsp-solargraph-autoformat t)
    (setopt lsp-solargraph-multi-root nil))

  (with-eval-after-load 'lsp-nix
    (setopt lsp-nix-nil-formatter '("nixpkgs-fmt"))
    (setopt lsp-nix-nil-max-mem 100000)))

(eval-when-compile
  (el-clone :repo "emacs-lsp/lsp-sourcekit"))

(with-delayed-execution
  (message "Install lsp-sourcekit...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/lsp-sourcekit"))

  (with-eval-after-load 'lsp-mode
    (require 'lsp-sourcekit)))

(eval-when-compile
  (el-clone :repo "emacs-lsp/emacs-ccls"))

(with-delayed-execution
  (message "Install emacs-ccls...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/emacs-ccls"))

  (with-eval-after-load 'lsp-mode
    (add-hook 'lsp-mode-hook #'(lambda () (require 'ccls)))))

(with-delayed-execution
  (message "Install lsp-php-key...")
  (with-eval-after-load 'lsp-php
    (setopt lsp-intelephense-licence-key "00OXTX8OROOJH9P")))

(eval-when-compile
  (el-clone :repo "gagbo/consult-lsp"))

(with-delayed-execution
  (message "Install consult-lsp...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/consult-lsp"))

  (autoload-if-found '(consult-lsp-symbols) "consult-lsp" nil t)

  (with-eval-after-load 'lsp-mode
    (define-key lsp-mode-map [remap xref-find-apropos] #'consult-lsp-symbols)))

(eval-when-compile
  (el-clone :repo "emacs-lsp/lsp-treemacs"))

(with-delayed-execution
  (message "Install lsp-treemacs...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/lsp-treemacs"))

  (autoload-if-found '(lsp-treemacs-sync-mode) "lsp-treemacs" nil t)

  (with-eval-after-load 'lsp-mode
    (add-hook 'lsp-mode-hook #'lsp-treemacs-sync-mode))

  (with-eval-after-load 'lsp-treemacs
    (setopt lsp-treemacs-error-list-severity 1)
    (setopt lsp-treemacs-error-list-current-project-only t)))

(eval-when-compile
  (el-clone :repo "emacs-lsp/lsp-docker"))

(with-delayed-execution
  (message "Install lsp-docker...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/lsp-docker"))

  (autoload-if-found '(lsp-docker-start) "lsp-docker" nil t))

(eval-when-compile
  (el-clone :repo "emacs-lsp/dap-mode"))

(with-delayed-execution
  (message "Install dap-mode...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/dap-mode"))

  (autoload-if-found '(dap-debug) "dap-mode" nil t)
  (autoload-if-found '(dap-hydra) "dap-hydra" nil t)
  (autoload-if-found '(dap-ui-mode dap-ui-controls-mode) "dap-ui" nil t)
  (autoload-if-found '(dap-tooltip-mode) "dap-mouse" nil t)
  (autoload-if-found '(dap-php-setup) "dap-php" nil t)
  (autoload-if-found '(dap-node-setup) "dap-node" nil t)
  (autoload-if-found '(dap-go-setup) "dap-go" nil t)
  (autoload-if-found '(dap-ruby-setup) "dap-ruby" nil t)

  (with-eval-after-load 'dap-mode
    ;; keybind
    (define-key dap-mode-map (kbd "C-c d") #'dap-breakpoint-toggle)

    ;; hook
    (add-hook 'dap-mode-hook #'dap-ui-mode)
    (add-hook 'dap-mode-hook #'dap-ui-controls-mode)
    (add-hook 'dap-mode-hook #'tooltip-mode)
    (add-hook 'dap-mode-hook #'dap-tooltip-mode)
    (add-hook 'dap-stopped-hook #'(lambda (arg) (call-interactively #'dap-hydra))))

  (with-eval-after-load 'php-mode
    (add-hook 'php-mode-hook #'dap-php-setup))

  (with-eval-after-load 'dap-php
    ;; config
    (setopt dap-php-debug-path `,(expand-file-name "xdebug/vscode-php-debug" dap-utils-extension-path))

    ;; register
    (dap-register-debug-template "Laravel Run Configuration"
                                 (list :type "php"
                                       :request "launch"
                                       :mode "remote"
                                       :host "localhost"
                                       :port 9003)))

  ;; (with-eval-after-load 'js2-mode
  ;;   (add-hook 'js2-mode-hook #'dap-node-setup))

  (with-eval-after-load 'go-mode
    (add-hook 'go-mode-hook #'dap-go-setup))

  (with-eval-after-load 'ruby-mode
    (add-hook 'ruby-mode-hook #'dap-ruby-setup)))

(eval-when-compile
  (el-clone :repo "emacs-lsp/lsp-ui"))

(with-delayed-execution
  (message "Install lsp-ui...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/lsp-ui"))

  (autoload-if-found '(lsp-ui-mode) "lsp-ui" nil t)

  ;; hook
  (with-eval-after-load 'lsp-mode
    (add-hook 'lsp-mode-hook #'lsp-ui-mode))

  ;; lsp-ui-doc
  (with-eval-after-load 'lsp-ui-doc
    (setopt lsp-ui-doc-enable t)
    (setopt lsp-ui-doc-show-with-cursor t)
    (setopt lsp-ui-doc-use-webkit t)
    (setopt lsp-ui-doc-include-signature t)
    (setopt lsp-ui-doc-delay 1)
    (setopt lsp-ui-doc-max-height 30))

  ;; lsp-ui-peek
  (autoload-if-found '(lsp-ui-peek-find-references lsp-ui-peek-find-definitions lsp-ui-peek-find-implementation) "lsp-ui-peek" nil t)
  (with-eval-after-load 'lsp-ui-peek
    (setopt lsp-ui-peek-enable nil)
    (setopt lsp-ui-peek-peek-height 30)
    (setopt lsp-ui-peek-list-width 60)
    (setopt lsp-ui-peek-fontify 'on-demand))

  ;; lsp-ui-imenu
  (autoload-if-found '(lsp-ui-imenu) "lsp-ui-imenu" nil t)
  (with-eval-after-load 'lsp-ui-imenu
    (setopt lsp-ui-imenu-enable nil)
    (setopt lsp-ui-imenu-kind-position 'top))

  ;; lsp-ui-sideline
  (autoload-if-found '(lsp-ui-sideline-mode) "lsp-ui-sideline" nil t)
  (with-eval-after-load 'lsp-ui-sideline
    (setopt lsp-ui-sideline-enable nil)
    (setopt lsp-ui-sideline-show-hover t))

  ;; keybind
  (with-eval-after-load 'lsp-mode
    (define-key lsp-mode-map (kbd "C-c C-r") #'lsp-ui-peek-find-references)
    (define-key lsp-mode-map (kbd "C-c C-j") #'lsp-ui-peek-find-definitions)
    (define-key lsp-mode-map (kbd "C-c C-i") #'lsp-ui-peek-find-implementation)
    (define-key lsp-mode-map (kbd "C-c C-m") #'lsp-ui-imenu)
    (define-key lsp-mode-map (kbd "C-c C-s") #'lsp-ui-sideline-mode)
    (define-key lsp-mode-map (kbd "C-c C-d") #'lsp-ui-doc-mode)))

(eval-when-compile
  (el-clone :repo "takeokunn/emacs-lsp-scheme"))

(with-delayed-execution
  (message "Install lsp-scheme...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/emacs-lsp-scheme"))

  (autoload-if-found '(lsp-scheme) "lsp-scheme" nil t)

  (with-eval-after-load 'scheme
    ;; (add-hook 'scheme-mode-hook #'lsp-scheme)
    )

  (with-eval-after-load 'lsp-scheme
    (setopt lsp-scheme-implementation "guile")))

(eval-when-compile
  (el-clone :repo "emacs-lsp/lsp-haskell"))

(with-delayed-execution
  (message "Install lsp-haskell...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/lsp-haskell"))

  (autoload-if-found '(lsp) "lsp-haskell" nil t)

  (with-eval-after-load 'haskell-mode
    (add-hook 'haskell-mode-hook #'lsp)
    (add-hook 'haskell-literate-mode-hook #'lsp)))

(eval-when-compile
  (el-clone :repo "emacs-lsp/lsp-pyright"))

(with-delayed-execution
  (message "Install lsp-pyright...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/lsp-pyright"))

  ;; (with-eval-after-load 'python-mode
  ;;   (add-hook 'python-mode-hook #'(lambda ()
  ;;                                   (require 'lsp-pyright)
  ;;                                   (lsp))))
  )

(eval-when-compile
  (el-clone :repo "manateelazycat/lsp-bridge"))

(with-delayed-execution
  (message "Install lsp-bridge...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/lsp-bridge"))

  (autoload-if-found '(lsp-bridge-mode) "lsp-bridge" nil t)

  (with-eval-after-load 'lsp-bridge
    ;; config
    (setopt lsp-bridge-php-lsp-server "phpactor")

    ;; keybind
    (define-key lsp-bridge-mode-map (kbd "M-.") #'lsp-bridge-find-impl)
    (define-key lsp-bridge-mode-map (kbd "C-c C-r") #'lsp-bridge-find-references)))

(with-delayed-execution
  (message "Install mu4e...")
  (add-to-list 'load-path (locate-user-emacs-file "/nix/store/iyqr1hy0195pzvd4rmn9cz5hxmzqj42j-emacs-mu4e-1.12.5/share/emacs/site-lisp/elpa/mu4e-1.12.5"))

  (autoload-if-found '(mu4e) "mu4e" nil t)

  (keymap-global-set "C-x C-w" #'mu4e)

  (with-eval-after-load 'mu4e
    ;; config
    (setopt mail-user-agent 'mu4e-user-agent))

  (with-eval-after-load 'mu4e-update
    ;; config
    (setopt mu4e-get-mail-command "offlineimap")
    (setopt mu4e-update-interval (* 5 60))
    (setopt mu4e-index-cleanup nil)
    (setopt mu4e-index-lazy-check t))

  (with-eval-after-load 'mu4e-view
    ;; config
    (setopt mu4e-split-view 'horizontal))

  (with-eval-after-load 'mu4e-folders
    ;; config
    (setopt mu4e-maildir-shortcuts '((:maildir "/INBOX" :key ?i)
                                   (:maildir "/Redmine" :key ?r)
                                   (:maildir "/GitHub" :key ?g)
                                   (:maildir "/Emacs" :key ?e)
                                   (:maildir "/Guix" :key ?u))))

  (with-eval-after-load 'mm-decode
    (add-to-list 'mm-discouraged-alternatives "text/html")
    (add-to-list 'mm-discouraged-alternatives "text/richtext")))

(eval-when-compile
  (el-clone :repo "lordpretzel/mu4e-views"))

(with-delayed-execution
  (message "Install mu4e-views...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/mu4e-views"))

  ;; (autoload-if-found '(mu4e-views-mu4e-select-view-msg-method
  ;;                      mu4e-views-cursor-msg-view-window-down
  ;;                      mu4e-views-cursor-msg-view-window-up
  ;;                      mu4e-views-toggle-auto-view-selected-message
  ;;                      mu4e-views-mu4e-view-as-nonblocked-html
  ;;                      mu4e-views-mu4e-use-view-msg-method) "mu4e-views" nil t)

  ;; (mu4e-views-mu4e-use-view-msg-method "html")

  ;; (with-eval-after-load 'mu4e
  ;;   (define-key mu4e-headers-mode-map (kbd "v") #'mu4e-views-mu4e-select-view-msg-method)
  ;;   (define-key mu4e-headers-mode-map (kbd "M-n") #'mu4e-views-mu4e-select-view-msg-method)
  ;;   (define-key mu4e-headers-mode-map (kbd "M-p") #'mu4e-views-cursor-msg-view-window-up)
  ;;   (define-key mu4e-headers-mode-map (kbd "f") #'mu4e-views-toggle-auto-view-selected-message)
  ;;   (define-key mu4e-headers-mode-map (kbd "f") #'mu4e-views-mu4e-view-as-nonblocked-html))

  ;; (with-eval-after-load 'mu4e-view
  ;;   (setopt mu4e-views-completion-method 'ivy)
  ;;   (setopt mu4e-views-default-view-method "html")
  ;;   (setopt mu4e-views-next-previous-message-behaviour 'stick-to-current-window)
  ;;   (setopt mu4e-views-auto-view-selected-message t))
  )

(eval-when-compile
  (el-clone :repo "rougier/mu4e-dashboard"))

(with-delayed-execution
  (message "Install mu4e-dashboard...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/mu4e-dashboard"))

  (autoload-if-found '() "mu4e-dashboard" nil t))

(eval-when-compile
  (el-clone :repo "lewang/command-log-mode"))

(with-delayed-execution
  (message "Install command-log-mode...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/command-log-mode"))

  (autoload-if-found '(clm/toggle-command-log-buffer) "command-log-mode" nil t)

  (defalias 'command-log #'clm/toggle-command-log-buffer))

(eval-when-compile
  (el-clone :repo "takeokunn/fancy-narrow"))

(with-delayed-execution
  (message "Install fancy-narrow...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/fancy-narrow"))

  (autoload-if-found '(fancy-narrow-mode) "fancy-narrow" nil t)

  ;; (with-eval-after-load 'org
  ;;   (add-hook 'org-mode-hook #'fancy-narrow-mode))

  ;; (with-eval-after-load 'elisp-mode
  ;;   (add-hook 'emacs-lisp-mode-hook #'fancy-narrow-mode))

  ;; (with-eval-after-load 'lisp-mode
  ;;   (add-hook 'lisp-mode-hook #'fancy-narrow-mode))

  ;; (with-eval-after-load 'clojure-mode
  ;;   (add-hook 'clojure-mode-hook #'fancy-narrow-mode))
  )

(eval-when-compile
  (el-clone :repo "gregsexton/origami.el"))

(with-delayed-execution
  (message "Install origami...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/origami"))

  (autoload-if-found '(global-origami-mode origami-recursively-toggle-node origami-recursively-toggle-node) "origami" nil t)
  (global-origami-mode)

  (keymap-global-set "C-c t" #'origami-recursively-toggle-node)
  (keymap-global-set "C-c C-t" #'origami-recursively-toggle-node))

(with-delayed-execution
  (message "Install proced...")
  (autoload-if-found '(proced) "proced" nil t)
  (add-hook 'proced-mode-hook #'(lambda () (proced-toggle-auto-update 1)))
  (with-eval-after-load 'proced
    (setopt proced-auto-update-interval 10)
    (setopt proced-tree-flag t)
    (setopt proced-format 'long)))

(eval-when-compile
  (el-clone :repo "travisjeffery/proced-narrow"))

(with-delayed-execution
  (message "Install proced-narrow...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/proced-narrow"))

  (autoload-if-found '(proced-narrow) "proced-narrow" nil t)

  (with-eval-after-load 'proced
    (define-key proced-mode-map (kbd "/") #'proced-narrow)))

(eval-when-compile
  (el-clone :repo "bbatsov/projectile"))

(with-delayed-execution-priority-high
  (message "Install projectile...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/projectile"))

  (autoload-if-found '(projectile-mode) "projectile" nil t)

  (projectile-mode)

  (defun my/update-projectile-known-projects ()
    (interactive)
    (projectile-clear-known-projects)
    (projectile-cleanup-known-projects)
    (setopt projectile-known-projects (mapcar
                                     (lambda (x)
                                       (abbreviate-file-name (concat x "/")))
                                     (split-string (shell-command-to-string "ghq list --full-path")))))

  (with-eval-after-load 'projectile
    ;; keybind
    (keymap-global-set "M-p" #'projectile-command-map)
    (keymap-global-set "C-c p" #'projectile-command-map)

    ;; hook
    (add-hook 'projectile-mode-hook #'my/update-projectile-known-projects)

    ;; config
    (setopt projectile-switch-project-action 'projectile-dired)
    (setopt projectile-enable-caching t)
    (setopt projectile-use-git-grep t)))

(eval-when-compile
  (el-clone :fetcher "gitlab" :repo "OlMon/consult-projectile"))

(with-delayed-execution
  (message "Install consult-projectile...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/consult-projectile"))

  (autoload-if-found '(consult-projectile-switch-to-buffer
                       consult-projectile-switch-to-buffer-other-window
                       consult-projectile-switch-to-buffer-other-frame
                       consult-projectile-find-dir
                       consult-projectile-find-file
                       consult-projectile-find-file-other-window
                       consult-projectile-find-file-other-frame
                       consult-projectile-recentf
                       consult-projectile-switch-project) "consult-projectile" nil t)

  (with-eval-after-load 'projectile
    (advice-add 'projectile-switch-to-buffer :override #'consult-projectile-switch-to-buffer)
    (advice-add 'projectile-switch-to-buffer-other-window :override #'consult-projectile-switch-to-buffer-other-window)
    (advice-add 'projectile-switch-to-buffer-other-frame :override #'consult-projectile-switch-to-buffer-other-frame)
    (advice-add 'projectile-find-dir :override #'consult-projectile-find-dir)
    (advice-add 'projectile-find-file :override #'consult-projectile-find-file)
    (advice-add 'projectile-find-file-other-window :override #'consult-projectile-find-file-other-window)
    (advice-add 'projectile-find-file-other-frame :override #'consult-projectile-find-file-other-frame)
    (advice-add 'projectile-recentf :override #'consult-projectile-recentf)
    (advice-add 'projectile-switch-project :override #'consult-projectile-switch-project)))

(eval-when-compile
  (el-clone :repo "Wilfred/emacs-refactor"))

(with-delayed-execution
  (message "Install emr...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/emacs-refactor"))

  (autoload-if-found '(emr-show-refactor-menu) "emr" nil t)

  (with-eval-after-load 'prog-mode
    (define-key prog-mode-map (kbd "M-RET") #'emr-show-refactor-menu)))

(eval-when-compile
  (el-clone :repo "emacs-jp/migemo"))

;; (with-delayed-execution
;;   (message "Install migemo...")
;;   (add-to-list 'load-path (locate-user-emacs-file "el-clone/migemo"))

;;   (autoload-if-found '(migemo-init) "migemo" nil t)

;;   (with-eval-after-load 'migemo
;;     (setopt migemo-command "cmigemo")
;;     (setopt migemo-dictionary "~/.nix-profile/share/migemo/utf-8/migemo-dict")
;;     (setopt migemo-user-dictionary nil)
;;     (setopt migemo-regex-dictionary nil)
;;     (setopt migemo-coding-system 'utf-8-unix)
;;     (setopt migemo-use-pattern-alist t)
;;     (setopt migemo-use-frequent-pattern-alist t))

;;   ;; (migemo-init)
;;   )

(eval-when-compile
  (el-clone :repo "mhayashi1120/Emacs-wgrep"))

(with-delayed-execution
  (message "Install wgrep...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/emacs-wgrep"))

  (autoload-if-found '(wgrep-setup) "wgrep" nil t)

  (with-eval-after-load 'grep
    (add-hook 'grep-setup-hook 'wgrep-setup)))

(eval-when-compile
  (el-clone :repo "minad/consult"))

(with-delayed-execution
  (message "Install consult...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/consult"))

  (autoload-if-found '(consult-bookmark
                       consult-buffer
                       consult-buffer-other-frame
                       consult-buffer-other-tab
                       consult-buffer-other-window
                       consult-complex-command
                       consult-find
                       consult-flycheck
                       consult-focus-lines
                       consult-git-grep
                       consult-global-mark
                       consult-goto-line
                       consult-grep
                       consult-history
                       consult-isearch-history
                       consult-keep-lines
                       consult-line
                       consult-line-multi
                       consult-locate
                       consult-man
                       consult-mark
                       consult-outline
                       consult-project-buffer
                       consult-register
                       consult-register-load
                       consult-register-store
                       consult-ripgrep
                       consult-yank-pop
                       consult-mode-command

                       ;; other
                       consult-preview-at-point-mode
                       consult-register-window) "consult" nil t)
  (autoload-if-found '(consult-compile-error) "consult-compile" nil t)
  (autoload-if-found '(consult-org-heading consult-org-agenda) "consult-org" nil t)
  (autoload-if-found '(consult-imenu consult-imenu-multi) "consult-imenu" nil t)
  (autoload-if-found '(consult-kmacro) "consult-kmacro" nil t)
  (autoload-if-found '(consult-xref) "consult-xref" nil t)

  ;; keybind
  ;; C-c bindings in `mode-specific-map'
  (keymap-global-set "C-c M-x" #'consult-mode-command)
  (keymap-global-set "C-c h" #'consult-history)

  ;; C-x bindings in `ctl-x-map'
  (keymap-global-set "C-x M-:" #'consult-complex-command)
  (keymap-global-set "C-x b" #'consult-buffer)
  (keymap-global-set "C-x 4 b" #'consult-buffer-other-window)
  (keymap-global-set "C-x 5 b" #'consult-buffer-other-frame)

  ;; Other custom bindings
  (keymap-global-set "M-y" #'consult-yank-pop)

  ;; M-g bindings in `goto-map'
  (keymap-global-set "M-g e" #'consult-compile-error)
  (keymap-global-set "M-g f" #'consult-flycheck)
  (keymap-global-set "M-g g" #'consult-goto-line)
  (keymap-global-set "M-g M-g" #'consult-goto-line)
  (keymap-global-set "M-g o" #'consult-outline)
  (keymap-global-set "M-g m" #'consult-mark)
  (keymap-global-set "M-g k" #'consult-global-mark)
  (keymap-global-set "M-g i" #'consult-imenu)
  (keymap-global-set "M-g I" #'consult-imenu-multi)

  ;; C-o bindings in `search-map'
  (keymap-global-set "C-o" #'(lambda ()
                                  (interactive)
                                  (let ((word (thing-at-point 'symbol 'no-properties)))
                                    (consult-line word))))

  ;; Isearch integration
  (with-eval-after-load 'isearch
    (define-key isearch-mode-map (kbd "M-e") #'consult-isearch-history))

  ;; Minibuffer history
  (with-eval-after-load 'minibuffer
    (define-key minibuffer-local-map (kbd "M-s") #'consult-history)
    (define-key minibuffer-local-map (kbd "M-r") #'consult-history))

  (with-eval-after-load 'simple
    (add-hook 'completion-list-mode #'consult-preview-at-point-mode))

  (with-eval-after-load 'register
    (advice-add #'register-preview :override #'consult-register-window))

  (with-eval-after-load 'xref
    (setopt xref-show-xrefs-function #'consult-xref)
    (setopt xref-show-definitions-function #'consult-xref)))

(eval-when-compile
  (el-clone :repo "minad/affe"))

(with-delayed-execution
  (message "Install affe...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/affe"))

  (autoload-if-found '(affe-grep) "affe" nil t)

  (with-eval-after-load 'affe
    (setopt affe-highlight-function 'orderless-highlight-matches)
    (setopt affe-find-command "fd --color=never --full-path")
    (setopt affe-regexp-function 'orderless-pattern-compiler)))

(eval-when-compile
  (el-clone :repo "mohkale/compile-multi"))

(with-delayed-execution
  (message "Install compile-multi...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/compile-multi"))
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/compile-multi/extensions/consult-compile-multi"))
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/compile-multi/extensions/compile-multi-embark"))

  (autoload-if-found '(compile-multi) "compile-multi" nil t)
  (autoload-if-found '(consult-compile-multi-mode) "consult-compile-multi" nil t)
  (autoload-if-found '(compile-multi-embark-mode) "compile-multi-embark" nil t)

  (keymap-global-set "C-x m" #'compile-multi)

  (with-eval-after-load 'consult
    (consult-compile-multi-mode))

  (with-eval-after-load 'embark
    (compile-multi-embark-mode)))

(eval-when-compile
  (el-clone :repo "minad/vertico"))

(with-delayed-execution
  (message "Install vertico...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/vertico"))
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/vertico/extensions"))

  (autoload-if-found '(vertico-mode) "vertico" nil t)
  (autoload-if-found '(vertico-directory-tidy
                       vertico-directory-enter
                       vertico-directory-delete-char
                       vertico-directory-delete-word) "vertico-directory" nil t)
  (autoload-if-found '(vertico-flat-mode) "vertico-flat" nil t)

  (vertico-mode)

  (with-eval-after-load 'rfn-eshadow
    (add-hook 'rfn-eshadow-update-overlay #'vertico-directory-tidy))

  (with-eval-after-load 'vertico
    (setopt vertico-count 8)
    (setopt vertico-cycle t)))

(eval-when-compile
  (el-clone :repo "minad/marginalia"))

(with-delayed-execution
  (message "Install marginalia...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/marginalia"))
  (autoload-if-found '(marginalia-mode) "marginalia" nil t)

  (marginalia-mode)

  (with-eval-after-load 'minibuffer
    (define-key minibuffer-local-map (kbd "M-A") #'marginalia-cycle)))

(eval-when-compile
  (el-clone :repo "oantolin/orderless"))

(with-delayed-execution
  (message "Install orderless...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/orderless"))

  (autoload-if-found '(orderless-all-completions
                       orderless-try-completion) "orderless" nil t)

  (with-eval-after-load 'minibuffer
    (setopt completion-styles '(orderless basic))
    ;; (setopt completion-category-overrides '((file (styles basic partial-completion))))

    (add-to-list 'completion-styles-alist '(orderless orderless-try-completion orderless-all-completions
                                                      "Completion of multiple components, in any order."))))

(eval-when-compile
  (el-clone :repo "purcell/exec-path-from-shell"))

(with-delayed-execution-priority-high
  (message "Install exec-path-from-shell...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/exec-path-from-shell"))

  (autoload-if-found '(exec-path-from-shell-initialize) "exec-path-from-shell")
  (exec-path-from-shell-initialize)

  (with-eval-after-load 'exec-path-from-shell
    (setopt exec-path-from-shell-variables '("PATH"
                                           "GEM_HOME"
                                           "GOROOT"
                                           "GOPATH"
                                           "LSP_USE_PLISTS"
                                           "TERM"
                                           "SSH_AUTH_SOCK"
                                           "NATIVE_FULL_AOT"
                                           "GPG_TTY"))))

(eval-when-compile
  (el-clone :repo "joaotavora/yasnippet"))

(with-delayed-execution
  (message "Install yasnippet...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/yasnippet"))

  (autoload-if-found '(yas-global-mode) "yasnippet" nil t)

  (yas-global-mode 1))

(eval-when-compile
 (el-clone :repo "mohkale/consult-yasnippet"))

(with-delayed-execution
  (message "Install consult-yasnippet...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/consult-yasnippet"))

  (autoload-if-found '(consult-yasnippet) "consult-yasnippet" nil t)

  (keymap-global-set "C-c y" #'consult-yasnippet)
  (keymap-global-set "C-c C-y" #'consult-yasnippet))

(eval-when-compile
  (el-clone :repo "jschaf/esup"))

(with-delayed-execution
  (message "Install esup...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/esup"))

  (autoload-if-found '(esup) "esup" nil t))

(eval-when-compile
  (el-clone :repo "lastquestion/explain-pause-mode"))

(with-delayed-execution
  (message "Install explain-pause-mode...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/explain-pause-mode"))

  (autoload-if-found '(explain-pause-mode) "explain-pause-mode" nil t))

(eval-when-compile
  (el-clone :repo "emacs-straight/disk-usage"))

(with-delayed-execution
  (message "Install disk-usage...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/disk-usage"))

  (autoload-if-found '(disk-usage disk-usage-here) "disk-usage" nil t))

(eval-when-compile
  (el-clone :repo "dacap/keyfreq"))

(with-delayed-execution
  (message "Install keyfreq...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/keyfreq"))

  (autoload-if-found '(keyfreq-mode keyfreq-autosave-mode) "keyfreq" nil t)

  (keyfreq-mode 1)
  (keyfreq-autosave-mode 1))

(eval-when-compile
  (el-clone :repo "davep/uptimes.el"))

(with-delayed-execution
  (message "Install uptimes...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/uptimes"))

  (autoload-if-found '(uptimes) "uptimes" nil t))

(eval-when-compile
  (el-clone :repo "jpkotta/syntax-subword"))

(with-delayed-execution
  (message "Install syntax-subword...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/syntax-subword"))

  (autoload-if-found '(global-syntax-subword-mode) "syntax-subword" nil t)

  (global-syntax-subword-mode))

(eval-when-compile
  (el-clone :repo "zk-phi/symon"))

(with-delayed-execution
  (message "Install symon...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/symon"))

  (autoload-if-found '(symon-mode) "symon" nil t)

  (when-guix
   (symon-mode)))

(with-delayed-execution
  (message "Install tab-bar...")
  (autoload-if-found '(tab-bar-mode
                       tab-bar-history-mode
                       tab-previous
                       tab-next) "tab-bar" nil t)

  (tab-bar-history-mode)

  (keymap-global-set "C-x C-t" tab-prefix-map)
  (keymap-global-set "M-[" #'tab-previous)
  (keymap-global-set "M-]" #'tab-next)

  (with-eval-after-load 'tab-bar
    (setopt tab-bar-close-button-show nil)
    (setopt tab-bar-close-last-tab-choice nil)
    (setopt tab-bar-close-tab-select 'left)
    (setopt tab-bar-history-mode nil)
    (setopt tab-bar-new-tab-choice "*scratch*")
    (setopt tab-bar-new-button-show nil)
    (setopt tab-bar-tab-name-truncated-max 12)
    (setopt tab-bar-separator " | "))

  (defun my/tab-bar-rename-tab ()
    (interactive)
    (let ((proj-name (projectile-project-name)))
      (tab-bar-rename-tab proj-name)))

  ;; rename tab-bar with projectile
  (define-key tab-prefix-map (kbd "r") #'my/tab-bar-rename-tab)

  ;; close neotree when tab bar action
  (advice-add 'tab-new :before #'(lambda (&rest _) (neotree-hide)))
  (advice-add 'tab-next :before #'(lambda (&rest _) (neotree-hide)))
  (advice-add 'tab-bar-switch-to-tab :before #'(lambda (&rest _) (neotree-hide)))

  ;; hook
  (add-hook 'tab-bar-mode-hook #'(lambda () (display-line-numbers-mode -1))))

(with-delayed-execution
  (message "Install autoinsert...")
  (autoload-if-found '(auto-insert-mode) "autoinsert" nil t)

  (auto-insert-mode)

  (with-eval-after-load 'autoinsert
    (setopt auto-insert-directory "~/.emacs.d/auto-insert")))

(eval-when-compile
  (el-clone :repo "rainstormstudio/nerd-icons.el"))

(with-delayed-execution-priority-high
  (message "Install nerd-icons...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/nerd-icons")))

(eval-when-compile
  (el-clone :repo "rainstormstudio/nerd-icons-dired"))

(with-delayed-execution
  (message "Install nerd-icons-dired...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/nerd-icons-dired"))

  (autoload-if-found '(nerd-icons-dired-mode) "nerd-icons-dired" nil t)

  (with-eval-after-load 'dired-mode
    (add-hook 'dired-mode-hook #'nerd-icons-dired-mode)))

(eval-when-compile
  (el-clone :repo "rainstormstudio/nerd-icons-completion"))

(with-delayed-execution
  (message "Install nerd-icons-completion...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/nerd-icons-completion"))

  (autoload-if-found '(nerd-icons-completion-marginalia-setup) "nerd-icons-completion" nil t)

  (nerd-icons-completion-marginalia-setup))

(eval-when-compile
  (el-clone :repo "emacs-dashboard/emacs-dashboard"))

(with-delayed-execution
  (message "Install dashboard...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/emacs-dashboard"))

  (autoload-if-found '(dashboard-refresh-buffer) "dashboard" nil t)

  (with-eval-after-load 'dashboard
    (setopt dashboard-startup-banner 'logo)
    (setopt dashboard-set-file-icons t)
    (setopt dashboard-startup-banner 4)
    (setopt dashboard-items '((recents . 10)))))

(eval-when-compile
  (el-clone :repo "gonewest818/dimmer.el"))

(with-eval-after-load 'dimmer
  (message "Install dimmer...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/dimmer"))

  (autoload-if-found '(dimmer-configure-which-key
                       dimmer-configure-org
                       dimmer-mode)
                     "dimmer" nil t)

  (dimmer-configure-which-key)
  (dimmer-configure-org)
  (dimmer-mode t))

(eval-when-compile
  (el-clone :repo "doomemacs/themes"
            :load-paths `(,(locate-user-emacs-file "el-clone/themes/extensions"))))

(with-delayed-execution-priority-high
  (message "Install doom-themes...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/themes"))
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/themes/extensions"))

  (autoload-if-found '(doom-themes-enable-org-fontification) "doom-themes-ext-org" nil t)

  (doom-themes-enable-org-fontification)

  (when (require 'doom-themes)
    (load-theme 'doom-dracula t))

  (with-eval-after-load 'doom-themes
    (setopt doom-themes-padded-modeline t)
    (setopt doom-themes-enable-bold t)
    (setopt doom-themes-enable-italic t)))

(eval-when-compile
  (el-clone :repo "seagle0128/doom-modeline"))

(with-delayed-execution-priority-high
  (message "Install doom-modeline...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/doom-modeline"))

  (autoload-if-found '(doom-modeline-mode) "doom-modeline" nil t)

  (doom-modeline-mode 1)
  (line-number-mode 0)
  (column-number-mode 0)

  (with-eval-after-load 'doom-modeline
    (setopt doom-modeline-buffer-file-name-style 'truncate-with-project)
    (setopt doom-modeline-icon `,(display-graphic-p))
    (setopt doom-modeline-major-mode-icon `,(display-graphic-p))
    (setopt doom-modeline-minor-modes nil)))

(with-delayed-execution
  (message "Install hl-line...")
  (autoload-if-found '(global-hl-line-mode) "hl-line-mode" nil t)

  (when (not window-system)
    (global-hl-line-mode))

  (with-eval-after-load 'hl-line
    (set-face-attribute 'hl-line nil :inherit nil)
    (set-face-background 'hl-line "#444642")))

(eval-when-compile
  (el-clone :repo "nonsequitur/idle-highlight-mode"))

(with-delayed-execution
  (message "Install idle-highlight-mode...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/idle-highlight-mode"))

  (autoload-if-found '(idle-highlight-mode) "idle-highlight-mode" nil t)

  (with-eval-after-load 'idle-highlight-mode
    (setopt idle-highlight-idle-time 0.1))

  (with-eval-after-load 'prog-mode
    (add-hook 'prog-mode-hook #'idle-highlight-mode)))

(eval-when-compile
  (el-clone :repo "jaypei/emacs-neotree"))

(with-delayed-execution
  (message "Install neotree...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/emacs-neotree"))

  (autoload-if-found '(neotree-hide neotree-dir neotree-make-executor neo-open-file neo-open-dir) "neotree" nil t)

  (defun my/neotree-toggle ()
    (interactive)
    (let ((default-directory (or (locate-dominating-file default-directory ".neotree")
                                 (locate-dominating-file default-directory ".git"))))
      (if (and (fboundp 'neo-global--window-exists-p)
               (neo-global--window-exists-p))
          (neotree-hide)
        (neotree-dir default-directory))))

  (keymap-global-set "C-q" #'my/neotree-toggle)

  (with-eval-after-load 'neotree
    ;; config
    (setopt neo-theme 'ascii)
    (setopt neo-show-hidden-files t)

    ;; hook
    (add-hook 'neotree-mode-hook #'(lambda () (display-line-numbers-mode -1)))

    ;; keybind
    (define-key neotree-mode-map (kbd "C-j") (neotree-make-executor
                                              :file-fn #'neo-open-file
                                              :dir-fn  #'neo-open-dir))))

(eval-when-compile
  (el-clone :repo "TeMPOraL/nyan-mode"))

(with-delayed-execution-priority-high
  (message "Install nyan-mode...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/nyan-mode"))

  (autoload-if-found '(nyan-mode) "nyan-mode" nil t)

  (nyan-mode)

  (with-eval-after-load 'nyan-mode
    (setopt nyan-cat-face-number 5)
    (setopt nyan-animate-nyancat t)))

(eval-when-compile
  (el-clone :repo "k-talo/volatile-highlights.el"))

(with-delayed-execution
  (message "Install volatile-highlights...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/volatile-highlights"))

  (autoload-if-found '(volatile-highlights-mode) "volatile-highlights" nil t)

  (volatile-highlights-mode t))

(eval-when-compile
  (el-clone :repo "nonsequitur/idle-highlight-mode"))

(with-delayed-execution
  (message "Install idle-highlight-mode...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/idle-highlight-mode"))

  (autoload-if-found '(idle-highlight-mode) "idle-highlight-mode" nil t)

  (with-eval-after-load 'prog-mode
    (add-hook 'prog-mode-hook #'idle-highlight-mode))

  (with-eval-after-load 'idle-highlight-mode
    (setopt idle-highlight-idle-time 0.1)))

(eval-when-compile
  (el-clone :repo "apchamberlain/undo-tree.el"))

(with-delayed-execution
  (message "Install undo-tree...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/undo-tree"))

  (autoload-if-found '(global-undo-tree-mode) "undo-tree" nil t)

  (global-undo-tree-mode))

(with-delayed-execution
  (message "Install view-mode...")

  (defun my/org-view-next-heading ()
    (interactive)
    (if (and (derived-mode-p 'org-mode)
             (org-at-heading-p))
        (org-next-visible-heading 1)
      (next-line)))

  (defun my/org-view-previous-heading ()
    (interactive)
    (if (and (derived-mode-p 'org-mode)
             (org-at-heading-p))
        (org-previous-visible-heading 1)
      (previous-line)))

  (defun my/view-tab ()
    (interactive)
    (when (and (derived-mode-p 'org-mode)
               (or (org-at-heading-p)
                   (org-at-property-drawer-p)))
      (let ((view-mode nil))
        (org-cycle))))

  (defun my/view-shifttab ()
    (interactive)
    (when (derived-mode-p 'org-mode)
      (let ((view-mode nil))
        (org-shifttab))))

  (defun my/org-edit-special ()
    (interactive)
    (when (derived-mode-p 'org-mode)
      (view-mode -1)
      (org-edit-special)))

  (defun my/org-ctrl-c-ctrl-c ()
    (interactive)
    (when (derived-mode-p 'org-mode)
      (view-mode -1)
      (org-ctrl-c-ctrl-c)))

  (defvar my/view-mode-timer nil)
  (defun my/enable-view-mode-automatically ()
    (if view-mode
        (when my/view-mode-timer
          (cancel-timer my/view-mode-timer))
      (setopt my/view-mode-timer (run-with-idle-timer (* 60 10) nil #'view-mode))))

  (add-hook 'view-mode-hook #'my/enable-view-mode-automatically)
  (advice-add 'view--disable :before #'(lambda (&rest _) (view-lock-mode -1)))

  (with-eval-after-load 'files
    (add-hook 'find-file-hooks #'view-mode))

  (with-eval-after-load "view"
    (define-key view-mode-map (kbd "f") #'forward-char)
    (define-key view-mode-map (kbd "b") #'backward-char)
    (define-key view-mode-map (kbd "n") #'my/org-view-next-heading)
    (define-key view-mode-map (kbd "p") #'my/org-view-previous-heading)
    (define-key view-mode-map (kbd "@") #'set-mark-command)
    (define-key view-mode-map (kbd "C-c '") #'my/org-edit-special)
    (define-key view-mode-map (kbd "C-c C-C") #'my/org-ctrl-c-ctrl-c)
    (define-key view-mode-map (kbd "e") nil)
    (define-key view-mode-map (kbd "C-j") nil)
    (define-key view-mode-map (kbd "C-i") #'my/view-tab)
    (define-key view-mode-map (kbd "S-C-i") #'my/view-shifttab)))

(eval-when-compile
  (el-clone :repo "s-fubuki/view-lock-mode"))

(with-delayed-execution
  (message "Install view-lock-mode...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/view-lock-mode"))

  (autoload-if-found '(view-lock-timer-start view-lock-quit) "view-lock-mode" nil t)

  (with-eval-after-load 'view
    (add-hook 'view-mode-hook #'view-lock-timer-start))

  (with-eval-after-load 'view-lock-mode
    (setopt view-lock-start-time (* 30 60))))

(eval-when-compile
  (el-clone :repo "zx2c4/password-store"))

(with-delayed-execution
  (message "Install password-store...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/password-store/contrib/emacs")))

(eval-when-compile
  (el-clone :repo "volrath/password-store-otp.el"))

(with-delayed-execution
  (message "Install password-store-otp...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/password-store-otp")))

(eval-when-compile
  (el-clone :repo "NicolasPetton/pass"))

(with-delayed-execution
  (message "Install pass...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/pass"))

  (autoload-if-found '(pass pass-view-mode) "pass" nil t)

  (add-to-list 'auto-mode-alist (cons (substitute-in-file-name "$HOME/ghq/github.com/takeokunn/password-store/.*\\.gpg") 'pass-view-mode))

  (with-eval-after-load 'pass
    (setopt pass-suppress-confirmations t)))

(with-eval-after-load 'comint
  (setopt comint-buffer-maximum-size 100000)
  (setopt comint-prompt-read-only t)
  (setopt comint-terminfo-terminal "eterm-256color"))

(eval-when-compile
  (el-clone :repo "bbatsov/crux"))

(with-delayed-execution
  (message "Install crux...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/crux"))

  (autoload-if-found '(crux-open-with
                       crux-smart-open-line-above
                       crux-cleanup-buffer-or-region
                       crux-view-url
                       crux-transpose-windows
                       crux-duplicate-current-line-or-region
                       crux-duplicate-and-comment-current-line-or-region
                       crux-rename-file-and-buffer
                       crux-visit-term-buffer
                       crux-kill-other-buffers
                       crux-indent-defun
                       crux-top-join-lines
                       crux-kill-line-backwards) "crux" nil t)

  ;; keybind
  (keymap-global-set "C-c o" #'crux-open-with)
  (keymap-global-set "C-S-o" #'crux-smart-open-line-above)
  (keymap-global-set "C-c u" #'crux-view-url)
  (keymap-global-set "C-x 4 t" #'crux-transpose-windows)
  (keymap-global-set "C-c d" #'crux-duplicate-current-line-or-region)
  (keymap-global-set "C-c M-d" #'crux-duplicate-and-comment-current-line-or-region)
  (keymap-global-set "C-c r" #'crux-rename-file-and-buffer)
  (keymap-global-set "C-c M-t" #'crux-visit-term-buffer)
  (keymap-global-set "C-c k" #'crux-kill-other-buffers)
  (keymap-global-set "C-M-z" #'crux-indent-defun)
  (keymap-global-set "C-^" #'crux-top-join-lines)
  (keymap-global-set "C-DEL" #'crux-kill-line-backwards))

(with-delayed-execution
  (message "Install delsel...")
  (autoload-if-found '(delete-selection-mode) "delsel" nil t)
  (delete-selection-mode))

(eval-when-compile
  (el-clone :repo "alphapapa/dogears.el"))

(with-delayed-execution
  (message "Install dogears...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/dogears"))

  (autoload-if-found '(dogears-go
                       dogears-back
                       dogears-forward
                       dogears-list
                       dogears-sidebar) "dogears" nil t)

  ;; keybind
  (keymap-global-set "M-g d" #'dogears-go)
  (keymap-global-set "M-g M-b" #'dogears-back)
  (keymap-global-set "M-g M-f" #'dogears-forward)
  (keymap-global-set "M-g M-d" #'dogears-list)
  (keymap-global-set "M-g M-D" #'dogears-sidebar))

(eval-when-compile
  (el-clone :repo "oantolin/embark"))

(with-delayed-execution
  (message "Install embark...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/embark"))

  (autoload-if-found '(embark-act embark-dwim embark-prefix-help-command) "embark" nil t)
  (autoload-if-found '(embark-consult-outline-candidates
                       embark-consult-imenu-candidates
                       embark-consult-imenu-or-outline-candidates) "embark-consult" nil t)

  (keymap-global-set "C-." #'embark-act)
  (keymap-global-set "C-h B" #'embark-prefix-help-command)

  (defmacro my/embark-ace-action (fn)
    `(defun ,(intern (concat "my/embark-ace-" (symbol-name fn))) ()
       (interactive)
       (with-demoted-errors "%s"
         (aw-switch-to-window (aw-select nil))
         (call-interactively (symbol-function ',fn)))))

  (defmacro my/embark-split-action (fn split-type)
    `(defun ,(intern (concat "my/embark-"
                             (symbol-name fn)
                             "-"
                             (car (last (split-string
                                         (symbol-name split-type) "-"))))) ()
       (interactive)
       (funcall #',split-type)
       (call-interactively #',fn)))

  (defun my/sudo-find-file (file)
    "Open FILE as root."
    (interactive "FOpen file as root: ")
    (when (file-writable-p file)
      (user-error "File is user writeable, aborting sudo"))
    (find-file (if (file-remote-p file)
                   (concat "/" (file-remote-p file 'method) ":"
                           (file-remote-p file 'user) "@" (file-remote-p file 'host)
                           "|sudo:root@"
                           (file-remote-p file 'host) ":" (file-remote-p file 'localname))
                 (concat "/sudo:root@localhost:" file))))

  (with-eval-after-load 'embark
    (setopt embark-mixed-indicator-delay 0.1)
    (setopt prefix-help-command #'embark-prefix-help-command)

    ;; ace-window
    (define-key embark-file-map     (kbd "o") (my/embark-ace-action find-file))
    (define-key embark-buffer-map   (kbd "o") (my/embark-ace-action switch-to-buffer))
    (define-key embark-bookmark-map (kbd "o") (my/embark-ace-action bookmark-jump))

    ;; split window(2)
    (define-key embark-file-map     (kbd "2") (my/embark-split-action find-file split-window-below))
    (define-key embark-buffer-map   (kbd "2") (my/embark-split-action switch-to-buffer split-window-below))
    (define-key embark-bookmark-map (kbd "2") (my/embark-split-action bookmark-jump split-window-below))

    ;; split window(3)
    (define-key embark-file-map     (kbd "3") (my/embark-split-action find-file split-window-right))
    (define-key embark-buffer-map   (kbd "3") (my/embark-split-action switch-to-buffer split-window-right))
    (define-key embark-bookmark-map (kbd "3") (my/embark-split-action bookmark-jump split-window-right))

    ;; sudo
    (define-key embark-file-map (kbd "S") #'my/sudo-find-file)

    ;; consult
    (add-hook 'embark-collect-mode-hook #'consult-preview-at-point-mode)))

(with-delayed-execution
  (message "Install goto-addr...")
  (autoload-if-found '(goto-address-prog-mode goto-address-mode) "goto-address" nil t)

  (with-eval-after-load 'prog-mode
    (add-hook 'prog-mode-hook #'goto-address-prog-mode))

  (with-eval-after-load 'text-mode
    (add-hook 'text-mode-hook #'goto-address-mode)))

(eval-when-compile
  (el-clone :repo "hniksic/emacs-htmlize"))

(with-delayed-execution
  (message "Install htmlize...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/emacs-htmlize"))

  (with-eval-after-load 'htmlize
    (setopt htmlize-html-charset 'utf-8)))

(with-delayed-execution
  (message "Install midnight...")
  (autoload-if-found '(midnight-mode) "midnight" nil t)
  (midnight-mode)
  (with-eval-after-load 'midnight
    (setopt clean-buffer-list-delay-general 1)))

(eval-when-compile
  (el-clone :repo "dengste/minimap"))

(with-delayed-execution
  (message "Install minimap...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/minimap"))

  (autoload-if-found '(minimap-mode) "minimap" nil t)

  (keymap-global-set "C-c m" #'minimap-mode)

  (with-eval-after-load 'minimap
    (setopt minimap-window-location 'right)
    (setopt minimap-update-delay 0.2)
    (setopt minimap-minimum-width 20)
    (setopt minimap-major-modes '(prog-mode org-mode))))

(eval-when-compile
  (el-clone :repo "AmaiKinono/puni"))

(with-delayed-execution
  (message "Install puni...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/puni"))

  (autoload-if-found '(puni-global-mode puni-disable-puni-mode) "puni" nil t)
  (puni-global-mode)

  (with-eval-after-load 'lisp-mode
    (add-hook 'lisp-mode-hook #'puni-disable-puni-mode))

  (with-eval-after-load 'emacs-lisp-mode
    (add-hook 'emacs-lisp-mode-hook #'puni-disable-puni-mode))

  (with-eval-after-load 'clojure-mode
    (add-hook 'clojure-mode-hook #'puni-disable-puni-mode))

  (with-eval-after-load 'lisp-interaction-mode
    (add-hook 'lisp-interacton-mode-hook #'puni-disable-puni-mode))

  (with-eval-after-load 'scheme
    (add-hook 'scheme-mode-hook #'puni-disable-puni-mode))

  (with-eval-after-load 'simple
    (add-hook 'eval-expression-minibuffer-setup-hook #'puni-disable-puni-mode))

  (with-eval-after-load 'ielm
    (add-hook 'inferior-emacs-lisp-mode-hook #'puni-disable-puni-mode))

  (with-eval-after-load 'minibuffer
    (add-hook 'minibuffer-mode-hook #'puni-disable-puni-mode)))

(eval-when-compile
  (el-clone :repo "emacsorphanage/quickrun"))

(with-delayed-execution
  (message "Install quickrun...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/quickrun"))

  (autoload-if-found '(quickrun) "quickrun" nil t))

(eval-when-compile
  (el-clone :repo "pashky/restclient.el"))

(with-delayed-execution
  (message "Install restclient...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/restclient"))

  (autoload-if-found '(restclient-mode) "restclient" nil t))

(eval-when-compile
  (el-clone :repo "Fuco1/smartparens"))

(with-delayed-execution
  (message "Install smartparens...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/smartparens"))

  (with-eval-after-load 'smartparens))

(eval-when-compile
  (el-clone :repo "jojojames/smart-jump"))

(with-delayed-execution
  (message "Install smart-jump...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/smart-jump"))

  (with-eval-after-load 'smart-jump))

(eval-when-compile
  (el-clone :repo "akicho8/string-inflection"))

(with-delayed-execution
  (message "Install string-inflection...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/string-inflection"))

  (autoload-if-found '(string-inflection-all-cycle) "string-inflection" nil t))

(eval-when-compile
  (el-clone :repo "nflath/sudo-edit"))

(with-delayed-execution
  (message "Install sudo-edit...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/sudo-edit"))

  (autoload-if-found '(sudo-edit-current-file) "sudo-edit" nil t))

(eval-when-compile
  (el-clone :repo "alphapapa/topsy.el"))

(with-delayed-execution
  (message "Install topsy...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/topsy"))

  (autoload-if-found '(topsy-mode) "topsy" nil t)
  ;; (with-eval-after-load 'prog-mode
  ;;   (add-hook 'prog-mode-hook #'topsy-mode))

  ;; (with-eval-after-load 'lsp-ui-mode
  ;;   (add-hook 'lsp-ui-mode-hook #'(lambda () (topsy-mode -1))))
  )

(eval-when-compile
  (el-clone :repo "nicferrier/emacs-uuid"))

(with-delayed-execution
  (message "Install uuid...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/emacs-uuid"))

  (autoload-if-found '(uuid-string) "uuid" nil t)

  (defun my/uuid ()
    (interactive)
    (insert (uuid-string)))

  (defalias 'uuid #'my/uuid))

(with-delayed-execution
  (autoload-if-found '(woman woman-find-file) "woman" nil t))

(eval-when-compile
  (el-clone :repo "abo-abo/ace-window"))

(with-delayed-execution
  (message "Install ace-window...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/ace-window"))

  (autoload-if-found '(ace-window) "ace-window" nil t)

  (keymap-global-set "C-x o" #'ace-window)

  (with-eval-after-load 'ace-window
    (setopt aw-dispatch-always t)
    (setopt aw-scope 'frame)
    (setopt aw-keys '(?a ?s ?d ?f ?g ?h ?j ?k ?l))
    (setopt aw-minibuffer-flag t)))

(eval-when-compile
  (el-clone :repo "joostkremers/writeroom-mode"))

(with-delayed-execution
  (message "Install writeroom-mode...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/writeroom-mode"))

  (autoload-if-found '(writeroom-mode
                       writeroom-decrease-width
                       writeroom-increase-width
                       writeroom-adjust-width
                       writeroom-width)
                     "writeroom-mode" nil t)

  (with-eval-after-load 'writeroom-mode
    ;; keybind
    (define-key writeroom-mode-map (kbd "C-M-<") #'writeroom-decrease-width)
    (define-key writeroom-mode-map (kbd "C-M->") #'writeroom-increase-width)
    (define-key writeroom-mode-map (kbd "C-M-=") #'writeroom-adjust-width)

    ;; config
    (setopt writeroom-width 150)
    (setopt writeroom-maximize-window nil)))

(eval-when-compile
  (el-clone :repo "emacsorphanage/zoom-window"))

(with-delayed-execution
  (message "Install zoom-window...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/zoom-window"))

  (autoload-if-found '(zoom-window-zoom) "zoom-window" nil t)

  (keymap-global-set "C-c C-z" #'zoom-window-zoom))

(eval-when-compile
  (el-clone :repo "emacs-pe/docker-tramp.el"))

(with-delayed-execution
  (message "Install docker-tramp...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/docker-tramp"))

  (autoload-if-found '(docker-tramp-add-method) "docker-tramp" nil t)
  (docker-tramp-add-method)

  (with-eval-after-load 'tramp
    (tramp-set-completion-function docker-tramp-method docker-tramp-completion-function-alist)))

(eval-when-compile
  (el-clone :repo "Ladicle/consult-tramp"))

(with-delayed-execution
  (message "Install consult-tramp...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/consult-tramp"))
  (autoload-if-found '(consult-tramp) "consult-tramp" nil t))

(eval-when-compile
  (el-clone :repo "emacsmirror/paredit"))

(with-delayed-execution
  (message "Install paredit...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/paredit"))

  (autoload-if-found '(enable-paredit-mode
                       paredit-forward-slurp-sexp
                       paredit-splice-sexp
                       paredit-define-keys)
                     "paredit" nil t)

  (keymap-global-set "C-c f" #'paredit-forward-slurp-sexp)
  (keymap-global-set "M-s" #'paredit-splice-sexp)

  (with-eval-after-load 'paredit
    (add-hook 'paredit-mode-hook #'paredit-define-keys))

  (with-eval-after-load 'lisp-mode
    (add-hook 'lisp-mode-hook #'enable-paredit-mode)
    (add-hook 'lisp-data-mode-hook #'enable-paredit-mode))

  (with-eval-after-load 'emacs-lisp-mode
    (add-hook 'emacs-lisp-mode-hook #'enable-paredit-mode))

  (with-eval-after-load 'clojure-mode
    (add-hook 'clojure-mode-hook #'enable-paredit-mode))

  (with-eval-after-load 'lisp-interaction-mode
    (add-hook 'lisp-interacton-mode-hook #'enable-paredit-mode))

  (with-eval-after-load 'scheme
    (add-hook 'scheme-mode-hook #'enable-paredit-mode))

  (with-eval-after-load 'simple
    (add-hook 'eval-expression-minibuffer-setup-hook #'enable-paredit-mode))

  (with-eval-after-load 'ielm
    (add-hook 'inferior-emacs-lisp-mode-hook #'enable-paredit-mode)))

(eval-when-compile
  (el-clone :repo "Fanael/rainbow-delimiters"))

(with-delayed-execution
  (message "Install rainbow-delimiters...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/rainbow-delimiters"))

  (autoload-if-found '(rainbow-delimiters-mode-enable) "rainbow-delimiters" nil t)

  (with-eval-after-load 'lisp-mode
    (add-hook 'lisp-mode-hook #'rainbow-delimiters-mode-enable))

  (with-eval-after-load 'emacs-lisp-mode
    (add-hook 'emacs-lisp-mode-hook #'rainbow-delimiters-mode-enable))

  (with-eval-after-load 'clojure-mode
    (add-hook 'clojure-mode-hook #'rainbow-delimiters-mode-enable))

  (with-eval-after-load 'scheme
    (add-hook 'scheme-mode-hook #'rainbow-delimiters-mode-enable)))

(eval-when-compile
  (el-clone :repo "slime/slime"
            :load-paths `(,(locate-user-emacs-file "el-clone/slime/lib")
                          ,(locate-user-emacs-file "el-clone/slime/contrib")
                          ,(locate-user-emacs-file "el-clone/slime/swank"))))

(with-delayed-execution
  (message "Install slime...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/slime"))
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/slime/lib"))
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/slime/contrib"))
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/slime/swank"))

  (require 'slime)
  (require 'slime-autoloads)

  (load (expand-file-name "$HOME/.roswell/helper.el"))

  (defun my/slime-history ()
    (interactive)
    (if (and (fboundp '-distinct)
             (fboundp 'f-read-text))
        (insert
         (completing-read
          "choice history: "
          (-distinct (read (f-read-text "~/.slime-history.eld")))))))

  (with-eval-after-load 'slime
    (setq slime-net-coding-system 'utf-8-unix))

  (with-eval-after-load 'slime-repl
    (define-key slime-repl-mode-map (kbd "C-c C-r") #'my/slime-history)))

(with-delayed-execution
  (message "Install hyperspec...")
  (autoload-if-found '(hyperspec-lookup) "hyperspec" nil t)

  (with-eval-after-load 'lisp-mode
    (define-key lisp-mode-map (kbd "C-c h") #'hyperspec-lookup)))

(eval-when-compile
  (el-clone :repo "xiongtx/eros"))

(with-delayed-execution
  (message "Install eros...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/eros"))

  (autoload-if-found '(eros-mode) "eros" nil t)

  (with-eval-after-load 'emacs-lisp
    (add-hook 'emacs-lisp-mode-hook #'eros-mode)))

(with-delayed-execution
  (message "Install eldoc...")
  (autoload-if-found '(turn-on-eldoc-mode) "eldoc" nil t)

  (with-eval-after-load 'elisp-mode
    (add-hook 'emacs-lisp-mode-hook #'turn-on-eldoc-mode)
    (add-hook 'lisp-interaction-mode-hook #'turn-on-eldoc-mode))

  (with-eval-after-load 'ielm
    (add-hook 'ielm-mode-hook #'turn-on-eldoc-mode)))

(eval-when-compile
  (el-clone :repo "emacs-elsa/trinary-logic"))

(with-delayed-execution
  (message "Install trinary...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/trinary-logic")))

(eval-when-compile
  (el-clone :repo "emacs-elsa/Elsa"))

(with-delayed-execution
  (message "Install elsa...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/Elsa"))
  (autoload-if-found '(elsa-run) "elsa" nil t))

(eval-when-compile
  (el-clone :repo "emacsmirror/lispxmp"))

(with-delayed-execution
  (message "Install lispxmp...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/lispxmp"))

  (autoload-if-found '(lispxmp) "lispxmp" nil t))

(eval-when-compile
  (el-clone :repo "joddie/macrostep"))

(with-delayed-execution
  (message "Install macrostep...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/macrostep"))

  (autoload-if-found '(macrostep-expand macrostep-mode) "macrostep" nil t)

  (with-eval-after-load 'elisp-mode
    (define-key emacs-lisp-mode-map (kbd "C-c e") #'macrostep-expand)))

(eval-when-compile
  (el-clone :repo "purcell/elisp-slime-nav"))

(with-delayed-execution
  (message "Install eslisp-slime-nav...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/elisp-slime-nav"))

  (autoload-if-found '(elisp-slime-nav-mode) "elisp-slime-nav" nil t)

  (with-eval-after-load 'elisp-mode
    (add-hook 'emacs-lisp-mode-hook #'elisp-slime-nav-mode))

  (with-eval-after-load 'ielm
    (add-hook 'ielm-mode-hook #'elisp-slime-nav-mode)))

(eval-when-compile
  (el-clone :repo "Malabarba/Nameless"))

(with-delayed-execution
  (message "Install nameless...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/Nameless"))

  (autoload-if-found '(nameless-mode) "nameless" nil t)

  (with-eval-after-load 'elisp-mode
    (add-hook 'emacs-lisp-mode-hook #'nameless-mode))

  (with-eval-after-load 'ielm
    (add-hook 'ielm-mode-hook #'nameless-mode)))

(eval-when-compile
  (el-clone :repo "Wilfred/elisp-refs"))

(with-delayed-execution
  (message "Install elisp-refs...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/elisp-refs"))

  (autoload-if-found '(elisp-refs-function
                       elisp-refs-macro
                       elisp-refs-variable
                       elisp-refs-special
                       elisp-refs-symbol) "elisp-refs" nil t))

(eval-when-compile
  (el-clone :repo "Fanael/highlight-quoted"))

(with-delayed-execution
  (message "Install highlight-quoted...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/highlight-quoted"))

  (autoload-if-found '(highlight-quoted-mode) "highlight-quoted" nil t)

  (with-eval-after-load 'elisp-mode
    (add-hook 'emacs-lisp-mode-hook #'highlight-quoted-mode)))

(eval-when-compile
  (el-clone :repo "Fanael/highlight-defined"))

(with-delayed-execution
  (message "Install highlight-defined...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/highlight-defined"))
  (autoload-if-found '(highlight-defined-mode) "highlight-defined" nil t)

  (with-eval-after-load 'elisp-mode
    (add-hook 'emacs-lisp-mode-hook #'highlight-defined-mode)))

(with-delayed-execution
  (when (autoload-if-found '(my/ielm-history) "ielm" nil t))
  (defun my/ielm-history ()
    (interactive)
    (insert
     (completing-read
      "choice history: "
      (progn
        (let ((history nil)
              (comint-input-ring nil))
          (dotimes (index (ring-length comint-input-ring))
            (push (ring-ref comint-input-ring index) history))
          history))))))

(eval-when-compile
  (el-clone :repo "didibus/anakondo"))

(with-delayed-execution
  (message "Install anakondo...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/anakondo"))

  (autoload-if-found '(anakondo-minor-mode) "anakondo" nil t)
  ;; (with-eval-after-load 'clojure-mode
  ;;   (add-hook 'clojure-mode-hook #'anakondo-minor-mode)
  ;;   (add-hook 'clojurescript-mode-hook #'anakondo-minor-mode)
  ;;   (add-hook 'clojurec-mode-hook #'anakondo-minor-mode))
  )

(eval-when-compile
  (el-clone :repo "clojure-emacs/parseclj")
  (el-clone :repo "clojure-emacs/parseedn")
  (el-clone :repo "clojure-emacs/cider"))

(with-delayed-execution
  (message "Install cider...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/parseclj"))
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/parseedn"))
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/cider"))

  (autoload-if-found '(cider cider-format-buffer cider-switch-to-last-clojure-buffer) "cider" nil t)
  (autoload-if-found '(cider-doc) "cider-doc" nil t)

  ;; (add-hook 'before-save-hook #'cider-format-buffer t t)

  (with-eval-after-load 'cider-common
    (setopt cider-special-mode-truncate-lines nil))

  (with-eval-after-load 'cider-mode
    (setopt cider-font-lock-reader-conditionals nil)
    (setopt cider-font-lock-dynamically '(macro core function var)))

  (with-eval-after-load 'cider-repl
    (setopt cider-repl-buffer-size-limit 1000000)
    (setopt cider-repl-wrap-history t)
    (setopt cider-repl-history-size 10000)
    (setopt cider-repl-tab-command #'indent-for-tab-command)
    (setopt cider-repl-display-in-current-window t))

  (with-eval-after-load 'nrepl-client
    (setopt nrepl-use-ssh-fallback-for-remote-hosts t)
    (setopt nrepl-hide-special-buffers t))

  (with-eval-after-load 'cider-eval
    (setopt cider-show-error-buffer nil)
    (setopt cider-auto-select-error-buffer nil))

  (with-eval-after-load 'clojure-mode
    (define-key clojure-mode-map (kbd "C-c h") #'cider-doc)))

(eval-when-compile
  (el-clone :repo "brunchboy/kibit-helper"))

(with-delayed-execution
  (message "Install kibit-helper...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/kibit-helper"))

  (autoload-if-found '(kibit kibit-current-file kibit-accept-proposed-change) "kibit-helper" nil t))

(eval-when-compile
  (el-clone :repo "clojure-emacs/clj-refactor.el"))

(with-delayed-execution
  (message "Install clj-refactor...")
  (add-to-list 'load-path (locate-user-emacs-file "el-clone/clj-refactor"))

  ;; (autoload-if-found '(clj-refactor-mode cljr-add-keybindings-with-prefix) "clj-refactor" nil t)

  ;; (add-hook 'clojure-mode-hook #'clj-refactor-mode)
  ;; (cljr-add-keybindings-with-prefix "C-c C-m")

  ;; (with-eval-after-load 'clj-refactor
  ;;   (setopt cljr-suppress-middleware-warnings t)
  ;;   (setopt cljr-hotload-dependencies t))
  )