init.org

:PROPERTIES:
:TOC:      :include all :force ((nothing)) :ignore ((nothing)) :local ((nothing))
:END:
#+TITLE: Emacs Init
#+AUTHOR: mattiasdrp
#+DATE: <2022-08-17 Wed>
#+LANGUAGE: en_US
#+PROPERTY: header-args :results silent :exports code :tangle yes
#+AUTO_TANGLE: t
#+STARTUP: hideblocks

#+KEYWORDS: Emacs

Literate configuration for init.el.

* Table of Contents
:PROPERTIES:
:TOC:      :include all :ignore this
:END:

:CONTENTS:
- [[#header][Header]]
- [[#global-options][Global options]]
  - [[#initialize-packages][Initialize packages]]
  - [[#install-and-set-use-package][Install and set use-package]]
  - [[#disable-warnings][Disable warnings]]
  - [[#disableenable-features][Disable/Enable features]]
  - [[#set-useful-variables][Set useful variables]]
    - [[#init-file][Init file]]
  - [[#revert-early-init][Revert early-init]]
  - [[#gc-when-emacs-is-idle-and-never-when-using-minibuffer][GC when emacs is idle and never when using minibuffer]]
  - [[#load-functions][Load functions]]
  - [[#change-frame-title-format][Change frame title format]]
  - [[#ask-yn-instead-of-yesno][Ask y/n instead of yes/no]]
  - [[#backup][Backup]]
  - [[#default-values][Default values]]
  - [[#start-emacs-as-a-server][Start emacs as a server]]
  - [[#repeat-mode][Repeat-mode]]
  - [[#revert-files-when-they-changed][Revert files when they changed]]
  - [[#show-parenthesis][Show parenthesis]]
  - [[#other-useful-global-modes][Other useful global modes]]
  - [[#add-some-files-to-text-mode][Add some files to text-mode]]
  - [[#delete-whitespace][Delete whitespace]]
  - [[#no-littering][No littering]]
  - [[#load-custom-file][Load custom file]]
  - [[#prettifying][Prettifying]]
  - [[#themes-etc][Themes etc]]
    - [[#swap-between-darklight-themes][Swap between dark/light themes]]
    - [[#solarized][Solarized]]
    - [[#doom-theme][Doom theme]]
  - [[#maximize-and-fullscreen-at-start-up][Maximize and fullscreen at start-up]]
- [[#requirements][Requirements]]
- [[#constants-and-variables][Constants and variables]]
- [[#packages-initialization-and-configuration][Packages initialization and configuration]]
- [[#gcmh][GCMH]]
  - [[#emacs-startup-profiler][Emacs startup profiler]]
- [[#history-and-prescience][History and prescience]]
  - [[#prescient][Prescient]]
  - [[#savehist][Savehist]]
- [[#wsl-specific][WSL Specific]]
- [[#fonts-and-character-encoding][Fonts and character encoding]]
  - [[#set-environment-to-utf-8][Set Environment to UTF-8]]
  - [[#all-the-icons-and-material-icons-for-specific-range][All the icons and material icons for specific range]]
    - [[#all-the-icons-completion][All the icons completion]]
  - [[#nerd-icons][Nerd-icons]]
    - [[#nerd-icons-completion][Nerd-icons completion]]
    - [[#nerd-icons-corfu][Nerd icons corfu]]
  - [[#ligatures][Ligatures]]
  - [[#ansi-color][Ansi color]]
  - [[#kurecolor][Kurecolor]]
  - [[#emojify][Emojify]]
- [[#keybindings][Keybindings]]
  - [[#general][General]]
  - [[#which-key][Which-key]]
  - [[#hydra][Hydra]]
  - [[#hydra-posframe][Hydra-posframe]]
  - [[#major-mode-hydra][Major-mode Hydra]]
  - [[#pretty-hydra][Pretty-hydra]]
  - [[#keycast][Keycast]]
  - [[#selected][Selected]]
  - [[#disabled-god-mode][DISABLED: God mode]]
- [[#general-utilities][General Utilities]]
  - [[#hydras-for-emacs][Hydras for emacs]]
  - [[#kill-ring-doesnt-kill-text-properties][Kill ring doesn't kill text properties]]
  - [[#isearchquery-replace][Isearch/Query-replace]]
  - [[#cursor][Cursor]]
  - [[#nlinum][Nlinum]]
  - [[#cheat-sheet][Cheat Sheet]]
  - [[#crux][Crux]]
  - [[#delete-block][Delete block]]
  - [[#discover-my-major][Discover my major]]
  - [[#helpful][Helpful]]
  - [[#easy-kill][Easy-kill]]
  - [[#json][JSON]]
  - [[#spell-and-grammar-checking][Spell and grammar checking]]
    - [[#lsp-ltex-plus][lsp-ltex-plus]]
    - [[#jinx][Jinx]]
  - [[#highlight-symbol][Highlight symbol]]
  - [[#moving][Moving]]
  - [[#multiple-cursors][Multiple cursors]]
  - [[#hide-region][Hide region]]
  - [[#hide-mode-line][Hide mode line]]
  - [[#view-large-files][View Large Files]]
  - [[#vundo][Vundo]]
  - [[#whitespace][Whitespace]]
  - [[#window-locking][Window locking]]
- [[#process-management][Process management]]
  - [[#proced][Proced]]
- [[#diredshell][Dired/Shell]]
  - [[#dired][Dired]]
  - [[#dirvish][Dirvish]]
    - [[#main-mode][Main mode]]
    - [[#extensions][Extensions]]
  - [[#dwim-shell-commands][Dwim shell commands]]
- [[#git][Git]]
  - [[#cond-let][Cond-let]]
  - [[#magit][Magit]]
  - [[#magit-delta][Magit delta]]
  - [[#magit-todos][Magit todos]]
  - [[#ediff][Ediff]]
  - [[#highlight-todo][Highlight todo]]
  - [[#git-messenger][Git messenger]]
  - [[#git-timemachine][Git timemachine]]
  - [[#git-modes][Git modes]]
  - [[#code-review][Code review]]
  - [[#ghub][Ghub]]
- [[#org-mode][Org mode]]
  - [[#main-mode-0][Main mode]]
  - [[#org-modern][Org modern]]
  - [[#graphviz-dot-mode][Graphviz-dot-mode]]
  - [[#org-auto-tangle][Org auto tangle]]
  - [[#disabled-org-ref][DISABLED Org ref]]
  - [[#org-inline-pdf][Org inline pdf]]
  - [[#calfw][Calfw]]
  - [[#calfw-org][Calfw org]]
  - [[#org-gcal][Org gcal]]
  - [[#org-super-agenda][Org super agenda]]
  - [[#org-appear][Org appear]]
  - [[#org-roam][Org roam]]
  - [[#org-make-toc][Org make toc]]
  - [[#org-cv][Org CV]]
- [[#collaborative-editing][Collaborative editing]]
- [[#lsp][LSP]]
  - [[#main-mode-1][Main mode]]
  - [[#lsp-ui][Lsp ui]]
  - [[#lsp-treemacs][Lsp treemacs]]
  - [[#consult-lsp][Consult lsp]]
- [[#prog-mode-utilities][Prog mode utilities]]
  - [[#prog-mode][Prog-mode]]
  - [[#apheleia][Apheleia]]
  - [[#dap][DAP]]
    - [[#main-mode-2][Main mode]]
  - [[#dumb-jump][Dumb jump]]
  - [[#find-sibling][Find-sibling]]
  - [[#fontify-face][Fontify face]]
  - [[#flycheck][Flycheck]]
    - [[#main-mode-3][Main mode]]
    - [[#flycheck-correct][Flycheck Correct]]
    - [[#quick-peek][Quick Peek]]
    - [[#flycheck-inline][Flycheck inline]]
    - [[#consult-flycheck][Consult flycheck]]
    - [[#flycheck-rust][Flycheck Rust]]
  - [[#hideshow][Hideshow]]
  - [[#projectile][Projectile]]
  - [[#separedit][Separedit]]
  - [[#treemacs][Treemacs]]
- [[#windowsframe-management][Windows/Frame management]]
  - [[#disabled-uniquify][DISABLED Uniquify]]
  - [[#winner][Winner]]
  - [[#ace-window][Ace window]]
  - [[#visual-fill-column][Visual fill column]]
  - [[#pokemacs-layout][Pokemacs layout]]
  - [[#window-purpose][Window Purpose]]
- [[#completion][Completion]]
  - [[#vertico][Vertico]]
    - [[#main-mode-4][Main mode]]
    - [[#vertico-directory][Vertico directory]]
    - [[#vertico-prescient][Vertico-prescient]]
    - [[#vertico-multiform][Vertico multiform]]
  - [[#consult][Consult]]
  - [[#embark][Embark]]
  - [[#corfu][Corfu]]
    - [[#main-mode-5][Main mode]]
    - [[#corfu-popupinfo][Corfu-popupinfo]]
    - [[#corfu-prescient][Corfu-prescient]]
    - [[#corfu-terminal][Corfu terminal]]
    - [[#corfu-doc-terminal][Corfu doc terminal]]
  - [[#emacs-configuration-for-minibuffers-and-completion][Emacs configuration for minibuffers and completion]]
  - [[#windmove][Windmove]]
  - [[#hotfuzz][Hotfuzz]]
  - [[#orderless][Orderless]]
  - [[#cape][Cape]]
  - [[#marginalia][Marginalia]]
  - [[#iedit][Iedit]]
  - [[#tempel][Tempel]]
- [[#gui][GUI]]
  - [[#mode-line][Mode-line]]
    - [[#anzu][Anzu]]
    - [[#doom-modeline][Doom modeline]]
    - [[#minions][Minions]]
  - [[#outline-major-and-minor-modes][Outline (major and minor modes)]]
    - [[#major-mode][Major mode]]
  - [[#rainbow-mode][Rainbow mode]]
  - [[#rainbow-delimiters][Rainbow delimiters]]
  - [[#pulsar][Pulsar]]
  - [[#solaire][Solaire]]
  - [[#dashboard][Dashboard]]
- [[#eaf][EAF]]
- [[#tree-sitter][Tree sitter]]
  - [[#treesit][Treesit]]
    - [[#main-mode-6][Main Mode]]
    - [[#treesit-auto][Treesit-auto]]
  - [[#tree-sitter-elisp][Tree sitter elisp]]
    - [[#main-mode-7][Main mode]]
    - [[#tree-sitter-folding][Tree sitter folding]]
  - [[#combobulate][Combobulate]]
- [[#programming-languages][Programming languages]]
  - [[#enabledisable-packages-related-to-languages][Enable/Disable packages related to languages]]
  - [[#markdown][Markdown]]
    - [[#main-mode-8][Main mode]]
    - [[#lsp-marksman][LSP-marksman]]
    - [[#markdown-toc][Markdown toc]]
    - [[#pandoc][Pandoc]]
  - [[#dataconfig-formats][Data/Config formats]]
    - [[#conf-mode][Conf mode]]
    - [[#json-mode][Json-mode]]
    - [[#dune-files][Dune files]]
    - [[#makefile][Makefile]]
  - [[#bash-ts-mode][Bash-ts-mode]]
  - [[#cc][C/C++]]
    - [[#main-mode-9][Main mode]]
    - [[#ccls][CCLS]]
  - [[#clojure][Clojure]]
    - [[#main-mode-10][Main mode]]
    - [[#cider][CIDER]]
  - [[#emacs-lisp][Emacs-Lisp]]
    - [[#main-mode-11][Main mode]]
    - [[#lisp-extra-font-lock][Lisp extra font lock]]
    - [[#puni][Puni]]
    - [[#flycheck-package][Flycheck package]]
    - [[#elsa][Elsa]]
    - [[#ellsp][Ellsp]]
    - [[#nameless][Nameless]]
    - [[#eros][Eros]]
    - [[#suggest][Suggest]]
    - [[#ipretty][Ipretty]]
    - [[#macrostep][Macrostep]]
    - [[#highlight-quoted][Highlight-quoted]]
    - [[#highlight-sexp][Highlight-sexp]]
  - [[#elm][Elm]]
  - [[#fsharp][Fsharp]]
  - [[#go][Go]]
  - [[#kotlin][Kotlin]]
  - [[#java][Java]]
  - [[#latex][LaTeX]]
  - [[#ligo][Ligo]]
  - [[#michelson][Michelson]]
  - [[#ocaml][OCaml]]
    - [[#useful-functions][Useful functions]]
    - [[#main-mode-12][Main mode]]
    - [[#tuareg-menhir][Tuareg Menhir]]
    - [[#dune-commands][Dune commands]]
    - [[#ocaml-utils][OCaml utils]]
  - [[#pdf-files][Pdf files]]
    - [[#saveplace-in-pdf][Saveplace in pdf]]
  - [[#python][Python]]
    - [[#main-mode-13][Main mode]]
    - [[#pyvenv][Pyvenv]]
    - [[#lsp-pyright][Lsp pyright]]
  - [[#racket][Racket]]
  - [[#reason][Reason]]
  - [[#rst][RST]]
  - [[#ruby][Ruby]]
  - [[#rust][Rust]]
  - [[#sicp][SICP]]
  - [[#web-modes][Web modes]]
    - [[#main-mode-14][Main mode]]
    - [[#css-mode][CSS mode]]
    - [[#simple-httpd][Simple HTTPD]]
    - [[#beautify][Beautify]]
  - [[#zig][Zig]]
- [[#shitty-wizards][Shitty wizards]]
  - [[#copilot][Copilot]]
  - [[#copilot-chat][Copilot-chat]]
  - [[#eca][ECA]]
- [[#end][End]]
:END:

* Header
:PROPERTIES:
:CUSTOM_ID: header
:END:

#+begin_src emacs-lisp
  ;;; init.el --- Emacs init configuration -*- lexical-binding: t -*-
  ;;

  ;; Copyright (c) 2022-2026 mattiasdrp and contributors.

  ;; Author: mattiasdrp
  ;; Maintainer: mattiasdrp <https://codeberg.org/mattiasdrp>
  ;; Created: 17 august 2022
  ;; Version: 1.0.0
  ;; Licence: MIT
  ;; Keywords: emacs, init, convenience, configuration
  ;; URL: https://codeberg.org/mattiasdrp/pokemacs
  ;; Package-Requires: ((emacs "29.1"))

  ;;; Commentary:

  ;; This file IS NOT intended to be edited! It was generated by init.org.
  ;; If you want to change it, edit init.org then M-x org-babel-tangle

  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  ;;; Code:

#+end_src

* Global options
:PROPERTIES:
:CUSTOM_ID: global-options
:END:
:PROPERTIES:


** Initialize packages
:PROPERTIES:
:CUSTOM_ID: initialize-packages
:END:

#+begin_src emacs-lisp
  (defvar elpaca-installer-version 0.12)
  (defvar elpaca-directory (expand-file-name "elpaca/" user-emacs-directory))
  (defvar elpaca-builds-directory (expand-file-name "builds/" elpaca-directory))
  (defvar elpaca-sources-directory (expand-file-name "sources/" elpaca-directory))
  (defvar elpaca-order '(elpaca :repo "https://github.com/progfolio/elpaca.git"
                                :ref nil :depth 1 :inherit ignore
                                :files (:defaults "elpaca-test.el" (:exclude "extensions"))
                                :build (:not elpaca-activate)))
  (let* ((repo  (expand-file-name "elpaca/" elpaca-sources-directory))
         (build (expand-file-name "elpaca/" elpaca-builds-directory))
         (order (cdr elpaca-order))
         (default-directory repo))
    (add-to-list 'load-path (if (file-exists-p build) build repo))
    (unless (file-exists-p repo)
      (make-directory repo t)
      (when (<= emacs-major-version 28) (require 'subr-x))
      (condition-case-unless-debug err
          (if-let* ((buffer (pop-to-buffer-same-window "*elpaca-bootstrap*"))
                    ((zerop (apply #'call-process `("git" nil ,buffer t "clone"
                                                    ,@(when-let* ((depth (plist-get order :depth)))
                                                        (list (format "--depth=%d" depth) "--no-single-branch"))
                                                    ,(plist-get order :repo) ,repo))))
                    ((zerop (call-process "git" nil buffer t "checkout"
                                          (or (plist-get order :ref) "--"))))
                    (emacs (concat invocation-directory invocation-name))
                    ((zerop (call-process emacs nil buffer nil "-Q" "-L" "." "--batch"
                                          "--eval" "(byte-recompile-directory \".\" 0 'force)")))
                    ((require 'elpaca))
                    ((elpaca-generate-autoloads "elpaca" repo)))
              (progn (message "%s" (buffer-string)) (kill-buffer buffer))
            (error "%s" (with-current-buffer buffer (buffer-string))))
        ((error) (warn "%s" err) (delete-directory repo 'recursive))))
    (unless (require 'elpaca-autoloads nil t)
      (require 'elpaca)
      (elpaca-generate-autoloads "elpaca" repo)
      (let ((load-source-file-function nil)) (load "./elpaca-autoloads"))))
  (add-hook 'after-init-hook #'elpaca-process-queues)
  (elpaca `(,@elpaca-order))
#+end_src

** Install and set use-package
:PROPERTIES:
:CUSTOM_ID: install-and-set-use-package
:END:

#+begin_src emacs-lisp
  ;; Install use-package support
  (elpaca bind-key)

  (elpaca elpaca-use-package
    ;; Enable :ensure use-package keyword.
    (elpaca-use-package-mode)
    ;; Assume :ensure t unless otherwise specified.
    (setopt use-package-always-ensure t))
#+end_src

Will be used to download non-emacs packages needed by emacs packages

#+begin_src emacs-lisp
  (use-package system-packages
    :ensure t
    :config (message "`system-packages' loaded"))

  (use-package use-package-ensure-system-package
    :ensure nil
    :after (system-packages)
    :config (message "`use-package-ensure-system-package' loaded"))
  (elpaca-wait)

  (eval-and-compile
    (setopt
     use-package-verbose t
     use-package-expand-minimally t
     use-package-compute-statistics t
     use-package-always-defer t
     use-package-enable-imenu-support t))
#+end_src

** Disable warnings
:PROPERTIES:
:CUSTOM_ID: disable-warnings
:END:


#+begin_src emacs-lisp
  (setq byte-compile-warnings '(cl-functions))
#+end_src

** Disable/Enable features
:PROPERTIES:
:CUSTOM_ID: disableenable-features
:END:

This is a list of custom variables that allow to enable/disable features. If you want to change them, ~M-x customize-variable <custom_variable>~ will change its value in [[file:custom.el][custom.el]] allowing to maintain your own [[file:custom.el][custom.el]] file that should never be updated by me. Don't enable or disable features in this file or it will make updating it harder.

#+begin_src emacs-lisp
  ;; Miscellaneous Packages
  (defgroup pokemacs nil
    "Customisation group for pokemacs"
    :group 'emacs
    :tag "Pokemacs customisation")

  (defgroup pokemacs-packages nil
    "Pokemacs packages options."
    :group 'pokemacs
    :tag "Packages")

  (defcustom use-dashboard nil
    "If non-nil, uses the dashboard packages.
    This package greets you with a nice startup screen"
    :group 'pokemacs-packages
    :type 'boolean
    :tag "󰕮 Dashboard")

  (defcustom use-delta nil
    "If non-nil, uses the git delta packages.
    This package improves the magit diff"
    :group 'pokemacs-packages
    :type 'boolean
    :tag "󰇂 Delta")

  (defcustom use-eaf nil
    "If non-nil, uses the Emacs application framework."
    :group 'pokemacs-packages
    :type 'boolean
    :tag "󰲋 Emacs Application Framework")

  (defcustom use-gcal nil
    "If non-nil, uses the org-gcal package.
    This package is used to link google calendars to org agendas.
    This is way too emacsy for most people"
    :group 'pokemacs-packages
    :type 'boolean
    :tag " Org Google Calendar")

  (defcustom use-god nil
    "If non-nil, uses the god (mode) packages.
    Similar to Vim's separation of command/insert modes"
    :group 'pokemacs-packages
    :type 'boolean
    :tag " God Mode")

  (defcustom use-magit-todos nil
    "If non-nil, show todos in the current project in magit buffer.
    If your project contains a lot of todos you may want to disable this package."
    :group 'pokemacs-packages
    :type 'boolean
    :tag " Magit todos")

  (defcustom use-mu4e nil
    "If non-nil, use mu4e and smtpmail.
    Reading your emails in emacs, what else?"
    :group 'pokemacs-packages
    :type 'boolean
    :tag " Mu4e")

  (defcustom use-org nil
    "If non-nil, install Org mode from it's git repo.
  Otherwise, the org provided with emacs will be used"
    :group 'pokemacs-languages
    :type 'boolean
    :tag " Org mode")

  (defcustom use-org-agenda-startup nil
    "Start the org agenda at startup.
    If you don't live the org life you don't need it.
    But you don't live the org life.
    That's on you."
    :group 'pokemacs-packages
    :type 'boolean
    :tag " Org Agenda")

  (defcustom use-org-roam nil
    "If non-nil, uses Org roam.
    The Zettelkasten method.
    In emacs.
    With org-mode."
    :group 'pokemacs-packages
    :type 'boolean
    :tag "󰠮 Zettelkasten/Org Roam")

  (defcustom use-pandoc nil
    "If non-nil, uses the pandoc packages.
    You know, for markdown. Because you don't use org-mode."
    :group 'pokemacs-packages
    :type 'boolean
    :tag " Pandoc")

  (defcustom use-posframe nil
    "If non-nil, uses the vertico-posframe packages.
    Instead of displaying candidate menus in the minibuffer display them in a fancy posframe."
    :group 'pokemacs-packages
    :type 'boolean
    :tag "󰹉 Posframe")

  (defcustom use-treemacs nil
    "If non-nil, uses the treemacs packages.
    Some people want vscode in their emacs. Don't gate-keep, give them their big tree."
    :group 'pokemacs-packages
    :type 'boolean
    :tag "󰙅 Treemacs")

  (defcustom use-window-purpose nil
    "If non-nil, uses the window-purpose package.
    Give windows a 'purpose' to prevent them from being populated by buffers that don't have the same purpose."
    :group 'pokemacs-packages
    :type 'boolean
    :tag "󰡃 Window Purpose")

  ;; Custom values

  (defgroup pokemacs-values nil
    "Pokemacs values options."
    :group 'pokemacs
    :tag "Values")

  (defcustom pokemacs-repeat-timeout 0.5
    "Time before repeat-mode exits."
    :group 'pokemacs-values
    :type 'integer
    :tag "Repeat")

  (defcustom pokemacs-which-key-idle-delay 0.5
    "Time before which-key appears."
    :group 'pokemacs-values
    :type 'integer
    :tag "󱎫 Which-key idle delay")

  (defcustom pokemacs-complete-keywords t
    "Complete keywords in LSP.
  Enabling this leads to a bug where your completion may replace the following word (see https://github.com/minad/cape/discussions/152)."
    :group 'pokemacs-values
    :type 'boolean
    :tag " Keyword Completion")

  (defcustom pokemacs-hotfuzz-module-path (expand-file-name "etc/hotfuzz/" user-emacs-directory)
    "Where should the dynamic hotfuzz module be installed."
    :group 'pokemacs-values
    :type 'string
    :tag " Hotfuzz")

  ;; Themes

  (defgroup pokemacs-appearance nil
    "Pokemacs appearance options."
    :group 'pokemacs
    :tag "Appearance")

  (defcustom pokemacs-mono-font "Fira Code"
    "Default mono font."
    :group 'pokemacs-appearance
    :type 'string
    :tag " Mono Font")

  (defcustom pokemacs-variable-font "Iosevka Aile"
    "Default variable font."
    :group 'pokemacs-appearance
    :type 'string
    :tag " Variable Font")

  (defcustom tuple-mono-font `(:font ,pokemacs-mono-font)
    "List of possible mono fonts (the first available one will be used).
    `pokemacs-mono-font' is the first checked font"
    :group 'pokemacs-appearance
    :type 'list
    :tag " Mono Fonts")

  (defcustom tuple-variable-font `(:font ,pokemacs-variable-font)
    "List of possible mono fonts (the first available one will be used).
    `pokemacs-variable-font' is the first checked font"
    :group 'pokemacs-appearance
    :type 'list
    :tag " Variable Fonts")

  (defcustom pokemacs-theme-type 'dark
    "Dark or light theme."
    :group 'pokemacs-appearance
    :type 'symbol
    :tag "󰔎 Dark/Light")

  (defcustom pokemacs-dark-theme 'doom-nord
    "Dark theme to load."
    :group 'pokemacs-appearance
    :type 'symbol
    :tag "󰖔 Dark Theme")

  (defcustom pokemacs-light-theme 'doom-nord-light
    "Light theme to load."
    :group 'pokemacs-appearance
    :type 'symbol
    :tag "󰖙 Light Theme")

  (defcustom pokemacs-proced-important-executables '("emacs" "ocamllsp" "dune")
    "Executables that should be highlighted in the proced buffer."
    :group 'pokemacs-appearance
    :type 'list
    :tag " Important executables")

  (defcustom use-all-the-icons nil
    "Use all-the-icons (when t) or nerd-icons (when nil).
    nerd-icons is a better choice and I plan to stop using all-the-icons completely."
    :group 'pokemacs-appearance
    :type 'boolean
    :tag " Icons")

  (defcustom use-header-line nil
    "Use the header-line as the mode-line."
    :group 'pokemacs-appearance
    :type 'boolean
    :tag "〜 Header-line")

  (defcustom use-ligature t
    "If non-nil, join graphemes to form single glyphs"
    :group 'pokemacs-appearance
    :type 'boolean
    :tag "Ꜩ Ligature")

  (defcustom use-inline-errors t
    "If non-nil, inline flycheck errors"
    :group 'pokemacs-appearance
    :type 'boolean
    :tag "󰼮 Inline Errors")

  (defcustom use-maximize nil
    "If non-nil, maximize Emacs at startup."
    :group 'pokemacs-appearance
    :type 'boolean
    :tag "󰊓 Maximize")

  (defcustom use-rainbow nil
    "If non-nil, don't be @thriim.
    Rainbowify parentheses and other things."
    :group 'pokemacs-appearance
    :type 'boolean
    :tag "󱃗 Rainbows")

  (defcustom use-solaire t
    "If non-nil, uses the solaire package.
    Distinguishes between \"real\" buffers and \"unreal\" ones by giving the latter a darker background."
    :group 'pokemacs-appearance
    :type 'boolean
    :tag " Solaire")

  (defcustom use-visual-fill nil
    "If non-nil, fill the frame when there's only one."
    :group 'pokemacs-appearance
    :type 'boolean
    :tag " Visual Fill")

  ;; Dictionaries

  (defgroup pokemacs-dictionaries nil
    "Pokemacs dictionaries options."
    :group 'pokemacs
    :tag "Dictionaries")

  (defcustom pokemacs-dict "en_GB"
    "Dictionary language.
    Specify the chosen language used by spell checking tools in pokemacs."
    :group 'pokemacs-dictionaries
    :type '(choice (const :tag "en_GB" "en_GB")
                   (const :tag "en_US" "en_US")
                   (const :tag "fr_FR" "fr_FR")
                   (const :tag "No dict" nil)
                   (string :tag "Other"))
    :tag " Dictionary")
#+end_src

** Set useful variables
:PROPERTIES:
:CUSTOM_ID: set-useful-variables
:END:

*** Init file
:PROPERTIES:
:CUSTOM_ID: init-file
:END:

#+begin_src emacs-lisp
  (setq user-init-file (or load-file-name (buffer-file-name)))
  (setq user-emacs-directory (file-name-directory user-init-file))
#+end_src

** Revert early-init
:PROPERTIES:
:CUSTOM_ID: revert-early-init
:END:

The default value to use for ~gc-cons-threshold~.
If you experience freezing, decrease this.
If you experience stuttering, increase this.

#+begin_src emacs-lisp
  (defvar better-gc-cons-threshold (* 128 1024 1024)) ; 128mb
#+end_src

#+begin_src emacs-lisp
  (add-hook 'emacs-startup-hook
            (lambda ()
              (setq file-name-handler-alist file-name-handler-alist-original)
              (makunbound 'file-name-handler-alist-original)))
#+end_src

** GC when emacs is idle and never when using minibuffer
:PROPERTIES:
:CUSTOM_ID: gc-when-emacs-is-idle-and-never-when-using-minibuffer
:END:

#+begin_src emacs-lisp
  (setopt
   gc-cons-threshold better-gc-cons-threshold
   gc-cons-percentage 0.1
   garbage-collection-messages nil)
#+end_src

** Load functions
:PROPERTIES:
:CUSTOM_ID: load-functions
:END:

#+begin_src emacs-lisp
  (defun update-to-load-path (folder)
    "Update FOLDER and its subdirectories to `load-path'."
    (let ((base folder))
      (unless (member base load-path)
        (add-to-list 'load-path base))
      (dolist (f (directory-files base))
        (let ((name (expand-file-name f base)))
          (when (and (file-directory-p name)
                     (not (equal f ".."))
                     (not (equal f ".")))
            (unless (member name load-path)
              (add-to-list 'load-path name)))))))

  (update-to-load-path (expand-file-name "lisp" user-emacs-directory))
#+end_src

** Change frame title format
:PROPERTIES:
:CUSTOM_ID: change-frame-title-format
:END:

#+begin_src emacs-lisp
(setq frame-title-format '(buffer-file-name "%b (%f)" "%b"))
#+end_src

** Ask y/n instead of yes/no
:PROPERTIES:
:CUSTOM_ID: ask-yn-instead-of-yesno
:END:

#+begin_src emacs-lisp
(fset 'yes-or-no-p 'y-or-n-p)
#+end_src

** Backup
:PROPERTIES:
:CUSTOM_ID: backup
:END:

#+begin_src emacs-lisp
  (setopt
   ;; Save backup files in a .backup directory
   backup-directory-alist `(("." . ,(expand-file-name ".backup" user-emacs-directory)))
   backup-by-copying t
   delete-old-versions t
   kept-new-versions 6
   kept-old-versions 2
   version-control t
   delete-by-moving-to-trash t)
#+end_src

** TODO Default values
:PROPERTIES:
:CUSTOM_ID: default-values
:END:

#+begin_src emacs-lisp
  (setopt
   ;; Briefly move cursor to the matching open-paren
   ;; even if it is not visible in the window.
   blink-matching-paren 'jump-offscreen

   ;; Show matching parenthesis even for comments
   blink-matching-paren-dont-ignore-comments t

   ;; Show matching parentheses even when on screen
   blink-matching-paren-on-screen t

   ;; Show column with line in the modeline
   column-number-mode t

   ;; Full comments per line
   comment-style 'indent

   ;; Always kill compilation process before starting another
   compilation-always-kill t

   ;; Save all buffers before compiling
   compilation-ask-about-save nil

   ;; TODO: Not exactly sure what this does
   compilation-context-lines t

   ;; TODO: Not exactly sure what this does
   compilation-error-screen-columns t

   ;; Scroll to the first error in the compilation buffer
   compilation-scroll-output 'first-error

   ;; Number of lines in a compilation window
   compilation-window-height 12

   ;; Ask before killing emacs
   confirm-kill-emacs 'y-or-n-p

   ;; Don't lock files, I know what I'm doing
   create-lockfiles nil

   ;; If two dired are opened with two different locations
   ;; copy command will copy from one to the other
   dired-dwim-target t

   ;; Show Keystrokes in Progress Instantly
   echo-keystrokes 0.1

   ;; Turn font lock mode for all modes that allow it
   ;; TODO: Specify a list when we'll start using tree-sitter
   font-lock-global-modes t

   ;; Never insert tabs when indenting (default is now to always use space)
   indent-tabs-mode nil

   ;; I know emacs, I really don't need the startup-screen
   inhibit-startup-screen t

   ;; Don't put anything in the scratch buffer
   initial-scratch-message nil

   ;; Move point by visual lines
   line-move-visual t

   ;; Highlight the location of the next-error in the source buffer
   next-error-highlight t

   ;; Highlight the locus indefinitely until some other locus replaces it.
   next-error-highlight-no-select t

   ;; Add a newline automatically at the end of the file upon save.
   require-final-newline t

   ;; Turn Off Cursor Alarms
   ring-bell-function 'ignore

   ;; Use the clipboard too when cutting and pasting
   select-enable-clipboard t

   ;; TODO: Not sure why I'm using it
   sentence-end-double-space nil

   ;; I don't need scroll bars
   scroll-bar-mode nil

   tab-width 2

   ;; Long lines will span on a continuation line (makes the whole line visible)
   truncate-lines nil

   ;; Save undos even when closing emacs
   undo-tree-auto-save-history t

   ;; yes or no replace by y or n everywhere
   use-short-answers t

   vc-follow-symlinks t

   ;; Flash the screen
   visible-bell nil)
#+end_src

 # TODO: Change ansi color COLORS "#424242" "#EF9A9A" "#C5E1A5" "#FFEE58" "#64B5F6" "#E1BEE7" "#80DEEA" "#E0E0E0"]

** Start emacs as a server
:PROPERTIES:
:CUSTOM_ID: start-emacs-as-a-server
:END:

#+begin_src emacs-lisp
  (use-package server
    :demand t
    :ensure nil
    :config
    (unless (server-running-p) (server-start))
    (message "`server' loaded"))
#+end_src

** Repeat-mode
:PROPERTIES:
:CUSTOM_ID: repeat-mode
:END:

#+begin_src emacs-lisp
  ;; Allows to repeat just one key to allow shorter key sequences
  (use-package repeat
    :ensure nil
    :init (repeat-mode t)
    :config
    (setopt repeat-exit-timeout nil)
    (defun pokemacs-set-repeat-exit-timeout (list)
      (dolist (command list)
        (put command 'repeat-exit-timeout pokemacs-repeat-timeout))))
#+end_src

** Revert files when they changed
:PROPERTIES:
:CUSTOM_ID: revert-files-when-they-changed
:END:

This allows to let emacs revert files automatically if they were not changed directly in a buffer (log files for example)

#+begin_src emacs-lisp
  (global-auto-revert-mode t)
  (auto-revert-mode t)
#+end_src

** Show parenthesis
:PROPERTIES:
:CUSTOM_ID: show-parenthesis
:END:

Not the same as ~blink-matching-paren*~ that triggers when you close a parenthesis. This will show the matching parenthesis when your cursor is on an open or closed parenthesis.

#+begin_src emacs-lisp
  (show-paren-mode 1)
#+end_src

The available styles are
~'parenthesis~: show the matching parenthesis
~'expression~: show the entire expression enclosed by the parenthesis
~'mixed~: show the matching paren if it is visible, and the expression
otherwise

Since this is highly user dependent (I see you @thriim), the variable ~show-paren-style~ should be set in [[file:custom.el][custom.el]]

** Other useful global modes
:PROPERTIES:
:CUSTOM_ID: other-useful-global-modes
:END:

- Display line numbers in the fringe (disabled for now because it messes with quick-peek)
  #+begin_src emacs-lisp
    ;; (global-display-line-numbers-mode t)
  #+end_src
- Save the place of the cursor when exiting the buffer
  #+begin_src emacs-lisp
    (setopt save-place-forget-unreadable-files t)
    (save-place-mode 1)
  #+end_src
- Replace selection when writing
  #+begin_src emacs-lisp
    (delete-selection-mode t)
  #+end_src
- So Long mitigates slowness due to extremely long lines.
/Currently available in Emacs master branch only!/
  #+begin_src emacs-lisp
    (when (fboundp 'global-so-long-mode)
      (global-so-long-mode))
  #+end_src
- Smooth scrolling
  #+begin_src emacs-lisp
    (pixel-scroll-precision-mode t)
  #+end_src

** Add some files to text-mode
:PROPERTIES:
:CUSTOM_ID: add-some-files-to-text-mode
:END:

#+begin_src emacs-lisp
  (use-package text-mode
    :ensure nil
    :custom
    (text-mode-ispell-word-completion nil)
    :init
    (add-to-list 'auto-mode-alist '("\\.in\\'" . text-mode))
    (add-to-list 'auto-mode-alist '("\\.out\\'" . text-mode))
    (add-to-list 'auto-mode-alist '("\\.args\\'" . text-mode))
  (add-to-list 'auto-mode-alist '("\\.wast\\'" . lisp-mode)))
#+end_src

** Delete whitespace
:PROPERTIES:
:CUSTOM_ID: delete-whitespace
:END:

#+begin_src emacs-lisp
  (add-hook 'before-save-hook 'delete-trailing-whitespace)
#+end_src

** No littering
:PROPERTIES:
:CUSTOM_ID: no-littering
:END:

Stop creating files everywhere and put them all in a single place

#+begin_src emacs-lisp
  (use-package no-littering
    :demand t
    :ensure (:wait t)
    :config (message "`no-littering' loaded"))
#+end_src

Create a ~#file#~ while waiting for it to be saved and for backup (if emacs crashes you can recover your previous session with ~M-x recover-session~)

#+begin_src emacs-lisp
  (auto-save-visited-mode 1)
  (setopt
   auto-save-default t
   auto-save-timeout 60
   auto-save-interval 200)
#+end_src

** Load custom file
:PROPERTIES:
:CUSTOM_ID: load-custom-file
:END:

#+begin_src emacs-lisp
  (setopt custom-file (expand-file-name "custom.el" user-emacs-directory))
  (load custom-file 'noerror)
#+end_src

** Prettifying
:PROPERTIES:
:CUSTOM_ID: prettifying
:END:

Enable prettifying everywhere

#+begin_src emacs-lisp
  (when use-ligature
    (global-prettify-symbols-mode t)
    (prettify-symbols-mode))
#+end_src

When the cursor in on a prettified symbol, unprettify it

#+begin_src emacs-lisp
  (setopt prettify-symbols-unprettify-at-point t)
#+end_src

** Themes etc
:PROPERTIES:
:CUSTOM_ID: themes-etc
:END:

*** Swap between dark/light themes
:PROPERTIES:
:CUSTOM_ID: swap-between-darklight-themes
:END:

#+begin_src emacs-lisp
  (use-package heaven-and-hell
    :demand t
    :config
    (setopt heaven-and-hell-theme-type pokemacs-theme-type)
    (setopt heaven-and-hell-themes
            `((light . ,pokemacs-light-theme)
              (dark . ,pokemacs-dark-theme)))
    (setopt heaven-and-hell-load-theme-no-confirm t)
    (message "`doom-themes' loaded"))

  (defalias 'pokemacs-toggle-theme 'heaven-and-hell-toggle-theme)
#+end_src

*** [[https://github.com/bbatsov/solarized-emacs][Solarized]]
:PROPERTIES:
:CUSTOM_ID: solarized
:END:

#+begin_src emacs-lisp
  (use-package solarized-emacs
    :ensure (solarized :host github :repo "bbatsov/solarized-emacs")
    :custom
    ;; make the fringe stand out from the background
    (solarized-distinct-fringe-background t)

    ;; Don't change the font for some headings and titles
    (solarized-use-variable-pitch nil)

    ;; make the modeline high contrast
    (solarized-high-contrast-mode-line t)

    ;; Use less bolding
    (solarized-use-less-bold nil)

    ;; Use more italics
    (solarized-use-more-italic t)

    ;; Use less colors for indicators such as git:gutter, flycheck and similar
    (solarized-emphasize-indicators t)

    ;; Don't change size of org-mode headlines (but keep other size-changes)
    (solarized-scale-org-headlines nil)

    ;; Change the size of markdown-mode headlines (off by default)
    (solarized-scale-markdown-headlines t)

    ;; Avoid all font-size changes
    (solarized-height-minus-1 1.0)
    (solarized-height-plus-1 1.0)
    (solarized-height-plus-2 1.0)
    (solarized-height-plus-3 1.0)
    (solarized-height-plus-4 1.0)

    ;; Highlight all numbers
    (solarized-highlight-numbers t))
#+end_src

*** [[https://github.com/doomemacs/themes][Doom theme]]
:PROPERTIES:
:CUSTOM_ID: doom-theme
:END:

Nice themes that can be previewed [[https://github.com/doomemacs/themes/tree/screenshots][here]]. Need to load it before custom to be able to use ~doom-color~

#+begin_src emacs-lisp
  (use-package doom-themes
    :demand t
    :after (heaven-and-hell)
    :ensure (:wait t)
    :init
    (defun pokemacs--reface (&rest _)
      "Reface some faces."
      (let ((bg-attribute (face-background 'region)))
        (when (featurep 'magit-diff)
          (custom-set-faces
           `(ediff-current-diff-A ((t (:weight normal :background ,(face-background 'magit-diff-removed-highlight)))))
           `(ediff-current-diff-B ((t (:weight normal :background ,(face-background 'magit-diff-added-highlight)))))
           `(ediff-even-diff-A ((t (:weight normal :background ,(face-background 'magit-diff-context-highlight)))))
           `(ediff-even-diff-B ((t (:weight normal :background ,(face-background 'magit-diff-added-highlight)))))
           `(ediff-fine-diff-A ((t (:inherit 'diff-refine-removed :weight normal))))
           `(ediff-fine-diff-B ((t (:inherit 'diff-refine-added :weight normal))))))
        (custom-set-faces
         `(org-block ((t :background ,(doom-darken (doom-color 'bg) 0.15))) t)
         `(org-block-begin-line ((t)) t)
         `(org-block-end-line ((t :foreground unspecified :background unspecified)))
         `(show-paren-match
           ((t
             (:foreground unspecified
                          :weight unspecified
                          :background ,(if (eq heaven-and-hell-theme-type 'dark)
                                           (doom-darken bg-attribute 0.15)
                                         (doom-lighten bg-attribute 0.15))
                          :bold nil))))
         `(show-paren-mismatch ((t (:foreground unspecified)))))))

    (defun pokemacs-disable-all-active-themes (&rest _)
      "Disable all currently active themes."
      (dolist (theme custom-enabled-themes)
        (disable-theme theme)))

    (defun pokemacs-load-theme ()
      (pokemacs-disable-all-active-themes)
      (heaven-and-hell-clean-load-themes (heaven-and-hell-themes-switch-to))
      (pokemacs--reface))

    (advice-add #'heaven-and-hell-toggle-theme :after #'pokemacs--reface)
    (advice-add #'consult-theme :after #'pokemacs--reface)

    :custom
    ;; use the colorful treemacs theme
    (doom-themes-treemacs-theme "doom-colors")
    :config
    ;; Enable flashing mode-line on errors
    (doom-themes-visual-bell-config)
    ;; Enable custom neotree theme (all-the-icons must be installed!)
    ;; (doom-themes-neotree-config)
    ;; or for treemacs users

    :config
    ;; (defvar pokemacs--font-lock-faces
    ;;   '(font-lock-doc-face
    ;;     font-lock-type-face
    ;;     font-lock-string-face
    ;;     font-lock-escape-face
    ;;     font-lock-number-face
    ;;     font-lock-regexp-face
    ;;     font-lock-keyword-face
    ;;     font-lock-bracket-face
    ;;     font-lock-builtin-face
    ;;     font-lock-comment-face
    ;;     font-lock-warning-face
    ;;     font-lock-operator-face
    ;;     font-lock-constant-face
    ;;     font-lock-delimiter-face
    ;;     font-lock-doc-markup-face
    ;;     font-lock-punctuation-face
    ;;     font-lock-variable-use-face
    ;;     font-lock-preprocessor-face
    ;;     font-lock-property-use-face
    ;;     font-lock-property-name-face
    ;;     font-lock-variable-name-face
    ;;     font-lock-function-call-face
    ;;     font-lock-function-name-face
    ;;     font-lock-negation-char-face
    ;;     font-lock-misc-punctuation-face
    ;;     font-lock-comment-delimiter-face))

    ;; (defvar pokemacs--font-lock-faces-light '())
    ;; (defvar pokemacs--font-lock-faces-dark '())

    ;; (defun pokemacs--populate-font-lock-faces-plist (faces)
    ;;   (load-theme pokemacs-light-theme t)
    ;;   (dolist (face faces)
    ;;     (message "--------- %S" face)
    ;;     (setq pokemacs--font-lock-faces-light (plist-put pokemacs--font-lock-faces-light face (face-foreground face))))
    ;;   (load-theme pokemacs-dark-theme t)
    ;;   (dolist (face faces)
    ;;     (message "--------- %S" face)
    ;;     (setq pokemacs--font-lock-faces-dark (plist-put pokemacs--font-lock-faces-dark face (face-foreground face)))))

    ;; (pokemacs--populate-font-lock-faces-plist pokemacs--font-lock-faces)
    ;; (defun assoc-other-face-attribute (face)
    ;;   (if (eq heaven-and-hell-theme-type 'dark)
    ;;       (plist-get pokemacs--font-lock-faces-light face)
    ;;     (plist-get pokemacs--font-lock-faces-dark face)))

    ;; (defun update-foreground-if-ediff-refine ()
    ;;   "Automatically update the foreground color in `ediff-mode` when text is changed
    ;;  and the overlay is 'ediff-refine'."
    ;;   (let ((overlay (car (overlays-at (point))))) ; Check for overlay at the beginning of the change
    ;;     (when (and overlay
    ;;                (or (overlay-get overlay 'ediff-fine-diff-A)
    ;;                    (overlay-get overlay 'ediff-fine-diff-B)))
    ;;       (let* ((face (get-text-property beg 'face)) ; Get the font-lock face at the beginning of the change
    ;;              (new-foreground-color (assoc-other-face-attribute face)))
    ;;         (when new-foreground-color
    ;;           (set-text-properties (point) (1+ (point))
    ;;                                (list (cons 'foreground-color new-foreground-color))))))))
    ;; Corrects (and improves) org-mode's native fontification.
    (doom-themes-org-config)
    (pokemacs-load-theme)
    (message "`doom-themes' loaded"))
#+end_src

** Maximize and fullscreen at start-up
:PROPERTIES:
:CUSTOM_ID: maximize-and-fullscreen-at-start-up
:END:

This can be opted in or out by customising ~use-maximize~.

#+begin_src emacs-lisp
  (when use-maximize
    (set-frame-parameter (selected-frame) 'fullscreen 'maximized)
    (add-to-list 'default-frame-alist '(fullscreen . maximized)))
#+end_src

* Requirements
:PROPERTIES:
:CUSTOM_ID: requirements
:END:

#+begin_src emacs-lisp
  (use-package cl-lib :ensure nil)
  (use-package package :ensure nil)
  (require 'pokemacs-functions)
#+end_src

* Constants and variables
:PROPERTIES:
:CUSTOM_ID: constants-and-variables
:END:

#+begin_src emacs-lisp
  (defconst pokemacs-sys/win32
    (eq system-type 'windows-nt)
    "Are we running on a WinTel system?")

  (defconst pokemacs-sys/linux
    (eq system-type 'gnu/linux)
    "Are we running on a GNU/Linux system?")

  (defconst pokemacs-sys/mac
    (eq system-type 'darwin)
    "Are we running on a Mac system?")

  (defvar pokemacs-fd-binary
    (cl-find-if #'executable-find (list "fdfind" "fd"))
    "The filename of the `fd' executable. On some distros it's 'fdfind' (ubuntu,
  debian, and derivatives). On most it's 'fd'.")
#+end_src

* Packages initialization and configuration
:PROPERTIES:
:CUSTOM_ID: packages-initialization-and-configuration
:END:

Before this part you shouldn't use any ~use-package~ function since it's not loaded yet.

* GCMH
:PROPERTIES:
:CUSTOM_ID: gcmh
:END:

#+begin_src emacs-lisp
  (use-package gcmh
    :demand t
    :custom
    (gcmh-idle-delay 'auto)  ; default is 15s
    (gcmh-auto-idle-delay-factor 10)
    (gcmh-high-cons-threshold (* 16 1024 1024))  ; 16mb
    :config (gcmh-mode 1))
#+end_src

** Emacs startup profiler
:PROPERTIES:
:CUSTOM_ID: emacs-startup-profiler
:END:

#+begin_src emacs-lisp
  (use-package esup
    :custom
    (esup-depth 0)
    :config
    (message "`esup' loaded"))
#+end_src

* History and prescience
:PROPERTIES:
:CUSTOM_ID: history-and-prescience
:END:

** [[https://github.com/radian-software/prescient.el][Prescient]]
:PROPERTIES:
:CUSTOM_ID: prescient
:END:

Sorting and filtering of completions

#+begin_src emacs-lisp
  (use-package prescient
    :demand t
    :config
    (prescient-persist-mode 1)
    (message "`prescient' loaded"))
#+end_src

** [[https://www.emacswiki.org/emacs/SaveHist][Savehist]]
:PROPERTIES:
:CUSTOM_ID: savehist
:END:

We're not only saving the minibuffer history but compile history too

#+begin_src emacs-lisp
  (use-package savehist
    :ensure nil
    :init
    (savehist-mode t)
    ;; Remember recently opened files
    (recentf-mode t)
    :custom
    (history-delete-duplicates t)
    :config
    ;; Persist 'compile' history
    (add-to-list 'savehist-additional-variables 'compile-history)
    (add-to-list 'recentf-exclude no-littering-var-directory)
    (add-to-list 'recentf-exclude no-littering-etc-directory)
    (message "`savehist' loaded"))
#+end_src

* WSL Specific
:PROPERTIES:
:CUSTOM_ID: wsl-specific
:END:

When working in WSL emacs will believe it's in a Linux environment when it's actually not

#+begin_src emacs-lisp
  (defun pokemacs-wsl-specific-function ()
    "Change some values if running on WSL"
    (when (getenv "WSLENV")
      (message "setting wsl env")
      (eshell-command "xmodmap -e 'keycode 191 = space'")
      (let ((cmd-exe "/mnt/c/Windows/System32/cmd.exe")
            (cmd-args '("/c" "start")))
        (when (file-exists-p cmd-exe)
          (setq browse-url-generic-program  cmd-exe
                browse-url-generic-args     cmd-args
                browse-url-browser-function 'browse-url-generic
                search-web-default-browser  'browse-url-generic)))))

  (add-hook 'after-init-hook #'pokemacs-wsl-specific-function)
#+end_src

* Fonts and character encoding
:PROPERTIES:
:CUSTOM_ID: fonts-and-character-encoding
:END:

** Set Environment to UTF-8
:PROPERTIES:
:CUSTOM_ID: set-environment-to-utf-8
:END:

Set the default coding system to UTF-8. This idea came from the Doom Emacs early-init.el file.

#+begin_src emacs-lisp
  (unless pokemacs-sys/win32
    (set-selection-coding-system 'utf-8)
    (prefer-coding-system 'utf-8)
    (set-language-environment "UTF-8")
    (set-default-coding-systems 'utf-8)
    (set-terminal-coding-system 'utf-8)
    (set-keyboard-coding-system 'utf-8)
    (setq locale-coding-system 'utf-8))
#+end_src

** [[https://github.com/domtronn/all-the-icons.el][All the icons]] and material icons for specific range
:PROPERTIES:
:CUSTOM_ID: all-the-icons-and-material-icons-for-specific-range
:END:

In order to use this package you need to run ~M-x all-the-icons-install~ the first time your configuration is loaded

#+begin_src emacs-lisp
  (use-package all-the-icons
    :if (display-graphic-p)
    :demand t
    :config
    (when use-all-the-icons
      (set-fontset-font t '(#xe3d0 . #xe909) "Material Icons"))
    (message "`all-the-icons' loaded"))
#+end_src

Other all-the-icons related packages:

#+begin_src emacs-lisp
  (when use-all-the-icons
    (use-package all-the-icons-dired
      :if (display-graphic-p)
      :hook (dired-mode . all-the-icons-dired-mode)
      :config
      (message "`all-the-icons-dired' loaded")))
#+end_src

*** [[https://github.com/iyefrat/all-the-icons-completion][All the icons completion]]
:PROPERTIES:
:CUSTOM_ID: all-the-icons-completion
:END:

#+begin_src emacs-lisp
  (when use-all-the-icons
    (use-package all-the-icons-completion
      :if (display-graphic-p)
      :init (all-the-icons-completion-mode)
      :after (marginalia all-the-icons)
      :hook (marginalia-mode . all-the-icons-completion-marginalia-setup)
      :config
      (message "`all-the-icons-completion' loaded")))
#+end_src

** [[https://github.com/rainstormstudio/nerd-icons.el][Nerd-icons]]
:PROPERTIES:
:CUSTOM_ID: nerd-icons
:END:

In order to use this package you need to run ~M-x nerd-icons-install-fonts~ the first time your configuration is loaded

#+begin_src emacs-lisp
    (unless use-all-the-icons
      (use-package nerd-icons
        :demand t
        :config
        (set-fontset-font t 'symbol
                          (cond
                           ((member "Symbols Nerd Font Mono" (font-family-list)) "Symbols Nerd Font Mono")
                           ((member "Segoe UI Symbol" (font-family-list)) "Segoe UI Symbol")
                           ((member "Apple Symbols" (font-family-list)) "Apple Symbols")
                           ((member "Symbola" (font-family-list)) "Symbola")))
        (set-fontset-font t 'emoji
                          (cond
                           ((member "Noto Color Emoji" (font-family-list)) "Noto Color Emoji")
                           ((member "Noto Emoji" (font-family-list)) "Noto Emoji")
                           ((member "Apple Color Emoji" (font-family-list)) "Apple Color Emoji")
                           ((member "Segoe UI Emoji" (font-family-list)) "Segoe UI Emoji")
                           ((member "Symbola" (font-family-list)) "Symbola")))
        (message "`nerd-icons' loaded")))
#+end_src

Other nerd-icons related packages:

#+begin_src emacs-lisp
  (unless use-all-the-icons
    (use-package nerd-icons-dired
      :hook (dired-mode . nerd-icons-dired-mode)
      :config (message "`nerd-icons-dired' loaded")))
#+end_src

*** [[https://github.com/rainstormstudio/nerd-icons-completion][Nerd-icons completion]]
:PROPERTIES:
:CUSTOM_ID: nerd-icons-completion
:END:

#+begin_src emacs-lisp
  (unless use-all-the-icons
    (use-package nerd-icons-completion
      :after (marginalia nerd-icons)
      :hook (marginalia-mode . nerd-icons-completion-marginalia-setup)
      :config
      (nerd-icons-completion-mode)
      (message "`nerd-icons-completion' loaded")))
#+end_src

*** [[https://github.com/LuigiPiucco/nerd-icons-corfu][Nerd icons corfu]]
:PROPERTIES:
:CUSTOM_ID: nerd-icons-corfu
:END:

#+begin_src emacs-lisp
  (use-package nerd-icons-corfu
    :demand t
    :after (nerd-icons corfu)
    :config
    (add-to-list 'corfu-margin-formatters #'nerd-icons-corfu-formatter)
    ;; Optionally:
    ;; (setq nerd-icons-corfu-mapping
    ;;       '((array :style "cod" :icon "symbol_array" :face font-lock-type-face)
    ;;         (boolean :style "cod" :icon "symbol_boolean" :face font-lock-builtin-face)
    ;;         ;; ...
    ;;         (t :style "cod" :icon "code" :face font-lock-warning-face)))
    ;; Remember to add an entry for `t', the library uses that as default.
    )

#+end_src

** [[https://github.com/mickeynp/ligature.el][Ligatures]]
:PROPERTIES:
:CUSTOM_ID: ligatures
:END:

#+begin_src emacs-lisp
  (when use-ligature
    (defcustom pokemacs-ligatures
      '(;; == === ==== => =| =>>=>=|=>==>> ==< =/=//=// =~
        ;; =:= =!=
        ;; ;; ;;;
        ("=" (rx (+ (or ">" "<" "|" "/" "~" ":" "!" "="))))
        (";" (rx (+ ";")))
        ;; && &&&
        ("&" (rx (+ "&")))
        ;; !! !!! !. !: !!. != !== !~
        ("!" (rx (+ (or "=" "!" "\." ":" "~"))))
        ;; ?? ??? ?:  ?=  ?.
        ("?" (rx (or ":" "=" "\." (+ "?"))))
        ;; %% %%%
        ("%" (rx (+ "%")))
        ;; |> ||> |||> ||||> |] |} || ||| |-> ||-||
        ;; |->>-||-<<-| |- |== ||=||
        ;; |==>>==<<==<=>==//==/=!==:===>
        ("|" (rx (+ (or ">" "<" "|" "/" ":" "!" "}" "\]"
                        "-" "=" ))))
        ;; \\ \\\ \/
        ("\\" (rx (or "/" (+ "\\"))))
        ;; ++ +++ ++++ +>
        ("+" (rx (or ">" (+ "+"))))
        ;; :: ::: :::: :> :< := :// ::=
        (":" (rx (or ">" "<" "=" "//" ":=" (+ ":"))))
        ;; // /// //// /\ /* /> /===:===!=//===>>==>==/
        ("/" (rx (+ (or ">"  "<" "|" "/" "\\" "\*" ":" "!"
                        "="))))
        ;; .. ... .... .= .- .? ..= ..<
        ("\." (rx (or "=" "-" "\?" "\.=" "\.<" (+ "\."))))
        ;; -- --- ---- -~ -> ->> -| -|->-->>->--<<-|
        ("-" (rx (+ (or ">" "<" "|" "~" "-"))))
        ;; *> */ *)  ** *** ****
        ("*" (rx (or ">" "/" ")" (+ "*"))))
        ;; www wwww
        ("w" (rx (+ "w")))
        ;; <> <!-- <|> <: <~ <~> <~~ <+ <* <$ </  <+> <*>
        ;; <$> </> <|  <||  <||| <|||| <- <-| <-<<-|-> <->>
        ;; <<-> <= <=> <<==<<==>=|=>==/==//=!==:=>
        ;; << <<< <<<<
        ("<" (rx (+ (or "\+" "\*" "\$" "<" ">" ":" "~"  "!"
                        "-"  "/" "|" "="))))
        ;; >: >- >>- >--|-> >>-|-> >= >== >>== >=|=:=>>
        ;; >> >>> >>>>
        (">" (rx (+ (or ">" "<" "|" "/" ":" "=" "-"))))
        ;; #: #= #! #( #? #[ #{ #_ #_( ## ### #####
        ("#" (rx (or ":" "=" "!" "(" "\?" "\[" "{" "_(" "_"
                     (+ "#"))))
        ;; ~~ ~~~ ~=  ~-  ~@ ~> ~~>
        ("~" (rx (or ">" "=" "-" "@" "~>" (+ "~"))))
        ;; __ ___ ____ _|_ __|____|_
        ("_" (rx (+ (or "_" "|"))))
        ;; Fira code: 0xFF 0x12
        ("0" (rx (and "x" (+ (in "A-F" "a-f" "0-9")))))
        ;; Fira code:
        "Fl"  "Tl"  "fi"  "fj"  "fl"  "ft"
        ;; The few not covered by the regexps.
        "{|"  "[|"  "]#"  "(*"  "}#"  "$>"  "^=")
      "List of all character sequences that should joined to form a single glyph."
      :group 'pokemacs-appearance
      :type '(repeat (choice string (cons string (sexp :tag "A valid regex"))))
      :tag " Ligatures")

    (use-package ligature
      :demand t
      :config
      ;; Enable the "www" ligature in every possible major mode
      (ligature-set-ligatures 't '("www"))
      ;; Enable traditional ligature support in eww-mode, if the
      ;; `variable-pitch' face supports it
      (ligature-set-ligatures 'eww-mode '("ff" "fi" "ffi"))
      ;; Enable all Fira Code ligatures in programming modes
      (ligature-set-ligatures 'prog-mode pokemacs-ligatures)
      ;; Enables ligature checks globally in all buffers. You can also do it
      ;; per mode with `ligature-mode'.
      (global-ligature-mode t)
      (message "`ligature' loaded")))
#+end_src

** [[https://www.emacswiki.org/emacs/AnsiColor][Ansi color]]
:PROPERTIES:
:CUSTOM_ID: ansi-color
:END:

#+begin_src emacs-lisp
  (use-package ansi-color
    :ensure nil
    :hook (shell-mode . ansi-color-for-comint-mode-on)
    :config (message "`ansi-color' loaded"))
#+end_src

ANSI coloring didn't work, xterm-color works as expected

#+begin_src emacs-lisp
  (use-package xterm-color
    :custom
    (compilation-environment '("TERM=xterm-256color"))
    :config
    (defun my/advice-compilation-filter (f proc string)
      (funcall f proc (xterm-color-filter string)))

    (advice-add 'compilation-filter :around #'my/advice-compilation-filter))
#+end_src

** [[https://github.com/emacsfodder/kurecolor][Kurecolor]]
:PROPERTIES:
:CUSTOM_ID: kurecolor
:END:

#+begin_src emacs-lisp
  (use-package kurecolor
    :config (message "`kurecolor' loaded"))
#+end_src

** [[https://github.com/iqbalansari/emacs-emojify][Emojify]]
:PROPERTIES:
:CUSTOM_ID: emojify
:END:

#+begin_src emacs-lisp
  (use-package emojify
    :config (message "`emojify' loaded"))
#+end_src

* Keybindings
:PROPERTIES:
:CUSTOM_ID: keybindings
:END:

** [[https://github.com/noctuid/general.el][General]]
:PROPERTIES:
:CUSTOM_ID: general
:END:

#+begin_src emacs-lisp
  (defun pokemacs-unfold-or-indent-for-tab (&optional arg)
    (interactive "P")
    (if (treesit-parser-list)
        (unless (call-interactively #'treesit-fold-open)
          (call-interactively #'indent-for-tab-command arg))
      (call-interactively #'indent-for-tab-command arg)))

  (use-package general
    :demand t
    :ensure (:wait t)
    :init
    (if (display-graphic-p)
        (general-unbind "C-z"))
    (general-unbind
      "C-o"
      "C-f"
      "C-x C-z"
      "M-z"
      "M-m"
      "M-l"
      "M-h"
      "M-/"
      "M-l"
      "M-f")
    (general-define-key
     [remap kill-buffer]                  'kill-current-buffer
     [remap ispell-word]                  'jinx-correct
     [remap indent-for-tab-command]       'pokemacs-unfold-or-indent-for-tab
     ;; Prefixed by C
     "C-x C-1"                 'delete-other-windows
     "C-x C-2"                 'split-window-below
     "C-x C-3"                 'split-window-right
     "C-x C-0"                 'delete-window

     "C-x &"                   'delete-other-windows
     "C-x é"                   'split-window-below
     "C-x \""                  'split-window-right
     "C-x à"                   'delete-window

     "C-x C-l"                 'toggle-truncate-lines
     "C-="                     'text-scale-increase
     "C-+"                     'text-scale-increase
     "C--"                     'text-scale-decrease
     "C-c b"                   'describe-personal-keybindings
     ;; Create new line contextualised by the previous one
     ;; (will add a comment if in comment mode for example)
     "C-<return>"              'default-indent-new-line
     ;; emacs autocompletion (not like company)
     "C-<tab>"                 'dabbrev-expand
     "C-n"                     'next-error
     "C-p"                     'previous-error

     "C-x C-o"                 'ace-window

     ;; rotate buffers and window arrangements
     "C-c r w"                 'rotate-window
     "C-c r l"                 'rotate-layout

     ;; Prefixed by M
     "M-u"                     'upcase-dwim

     "M-J"                     (lambda () (interactive) (pokemacs-resize-window t 5))
     "M-L"                     (lambda () (interactive) (pokemacs-resize-window t -5))
     "M-I"                     (lambda () (interactive) (pokemacs-resize-window nil 5))
     "M-K"                     (lambda () (interactive) (pokemacs-resize-window nil -5))
     ;; Custom comment overwriting comment-dwim key binding
     "M-;"                     'pokemacs-comment-eclipse
     "M-p"                     'backward-paragraph
     "M-<f1>"                  'kill-current-buffer
     "M-Q"                     'unfill-paragraph

     "M-+"                     'hs-toggle-hiding
     "M-*"                     'hs-show-all

     ;; Function keys
     [f3]                      'next-match
     [(shift f3)]              'prev-match
     [f4]                      'goto-line
     [f7]                      'next-error
     [f8]                      'normal-mode)
    (general-define-key
     :prefix "M-z"
     ;; Setup shorcuts for window resize width and height
     "w"                       'pokemacs-resize-window-width
     "h"                       'pokemacs-resize-window-height)
    (general-define-key
     :prefix "M-h"
     "d"                       '("Date Utils" . hydra-dates/body)
     "f"                       '("Flycheck" . hydra-flycheck/body)
     "g"                       '("Git/Smerge" . hydra-smerge/body)
     "w"                       '("Window" . hydra-window/body)
     "t"                       '("Toggles" . pokemacs-toggles/body))
    (general-def minibuffer-local-map
      "C-<tab>" 'dabbrev-expand)
    :config (message "`general' loaded"))
#+end_src

** [[https://github.com/justbur/emacs-which-key][Which-key]]
:PROPERTIES:
:CUSTOM_ID: which-key
:END:

Useful packages that allows to see the possible keys after starting a combination of keys.

#+begin_src emacs-lisp
  (use-package which-key
    :init (which-key-mode)
    :custom
    (which-key-separator " ")
    (which-key-prefix-prefix "+")
    (which-key-sort-order 'which-key-key-order-alpha)
    (which-key-side-window-max-width 0.33)
    (which-key-show-early-on-C-h t)
    (which-key-idle-delay pokemacs-which-key-idle-delay)
    :config
    (which-key-add-major-mode-key-based-replacements 'markdown-mode
      "C-c TAB" "markdown/images"
      "C-c C-a" "markdown/links"
      "C-c C-c" "markdown/process"
      "C-c C-s" "markdown/style"
      "C-c C-t" "markdown/header"
      "C-c C-x" "markdown/structure"
      "C-c m" "markdown/personal")
    (which-key-add-major-mode-key-based-replacements 'web-mode
      "C-c C-a" "web/attributes"
      "C-c C-b" "web/blocks"
      "C-c C-d" "web/dom"
      "C-c C-e" "web/element"
      "C-c C-t" "web/tags")
    (which-key-setup-side-window-bottom)
    (message "`which-key' loaded"))
#+end_src

** [[https://github.com/abo-abo/hydra][Hydra]]
:PROPERTIES:
:CUSTOM_ID: hydra
:END:

Not using it to its full potential right now but only for useful dates:

#+begin_src emacs-lisp
  (use-package hydra
    :demand t
    :ensure (:wait t)
    :custom
    (hydra-default-hint nil)
    (hydra-look-for-remap t)
    :init

    (defun pokemacs-date-iso ()
      "Insert the current date, ISO format, eg. 2016-12-09."
      (interactive)
      (insert (format-time-string "%F")))

    (defun pokemacs-date-iso-with-time ()
      "Insert the current date, ISO format with time, eg. 2016-12-09T14:34:54+0100."
      (interactive)
      (insert (format-time-string "%FT%T%z")))

    (defun pokemacs-date-long ()
      "Insert the current date, long format, eg. December 09, 2016."
      (interactive)
      (insert (format-time-string "%d %B %Y")))

    (defun pokemacs-date-long-with-time ()
      "Insert the current date, long format, eg. December 09, 2016 - 14:34."
      (interactive)
      (insert (capitalize (format-time-string "%d %B %Y - %H:%M"))))

    (defun pokemacs-date-short ()
      "Insert the current date, short format, eg. 2016.12.09."
      (interactive)
      (insert (format-time-string "%Y.%m.%d")))

    (defun pokemacs-date-short-with-time ()
      "Insert the current date, short format with time, eg. 2016.12.09 14:34"
      (interactive)
      (insert (format-time-string "%Y.%m.%d %H:%M")))
    :config
    (message "`hydra' loaded"))
#+end_src

** [[https://github.com/Ladicle/hydra-posframe][Hydra-posframe]]
:PROPERTIES:
:CUSTOM_ID: hydra-posframe
:END:

#+begin_src emacs-lisp
  ;; NOTE: hydra and posframe are required
  (when use-posframe
    (use-package hydra-posframe
      :ensure (:type git :host github :repo "Ladicle/hydra-posframe")
      :hook (after-init . hydra-posframe-mode)))
#+end_src

** [[https://github.com/jerrypnz/major-mode-hydra.el][Major-mode Hydra]]
:PROPERTIES:
:CUSTOM_ID: major-mode-hydra
:END:

#+begin_src emacs-lisp
  (use-package major-mode-hydra
    :ensure (:wait t)
    :demand t
    :general
    ("M-h h" '("Major mode" . major-mode-hydra))
    ("M-h m" '("Custom mode" . pokemacs-major-mode-hydra-custom))
    :custom
    (major-mode-hydra-invisible-quit-key "q")
    :config
    (defun pokemacs-major-mode-hydra-custom (mode)
      (interactive
       (list
        (intern
         (completing-read
          "Describe custom theme: "
          (mapcar #'symbol-name
                  (buffer-local-value 'local-minor-modes (current-buffer)))))))
      (major-mode-hydra-dispatch mode))

    (defun major-mode-hydra-dispatch (mode)
      "Summon the hydra for given MODE (if there is one)."
      (let ((orig-mode mode))
        (catch 'done
          (while mode
            (let ((hydra (major-mode-hydra--body-name-for mode)))
              (when (fboundp hydra)
                (call-interactively hydra)
                (throw 'done t)))
            (setq mode (or (get mode 'derived-mode-parent) 'root-mode))))))

    (setq major-mode-hydra-title-generator
          '(lambda (mode)
             (let ((icon (all-the-icons-icon-for-mode mode :v-adjust 0.05)))
               (if (stringp icon)
                   (s-concat "\n"
                             (s-repeat 7 " ")
                             icon
                             " "
                             (s-capitalize (symbol-name mode))
                             " commands")
                 (s-concat "\n"
                           (s-repeat 10 " ")
                           (s-capitalize (symbol-name mode))
                           " commands"))))))
#+end_src

** Pretty-hydra
:PROPERTIES:
:CUSTOM_ID: pretty-hydra
:END:

#+begin_src emacs-lisp
  (use-package pretty-hydra
    :ensure nil
    :config
    (pretty-hydra-define
      hydra-dates (:color teal :title "Dates" :quit-key "q")
      ("Insert"
       (("d" pokemacs-date-short "short")
        ("i" pokemacs-date-iso "iso")
        ("l" pokemacs-date-long "long"))

       "Insert with time"
       (("D" pokemacs-date-short-with-time "short")
        ("I" pokemacs-date-iso-with-time "iso")
        ("L" pokemacs-date-long-with-time "long")))))
#+end_src

** [[https://github.com/tarsius/keycast/][Keycast]]
:PROPERTIES:
:CUSTOM_ID: keycast
:END:

Needs to be manually activated. Will display all the actions made.

#+begin_src emacs-lisp
  (use-package keycast
    :commands keycast-mode
    :config
    (define-minor-mode keycast-mode
      "Show current command and its key binding in the mode line (fix for use with doom-mode-line)."
      :global t
      (if keycast-mode
          (add-hook 'pre-command-hook 'keycast--update t)
        (remove-hook 'pre-command-hook 'keycast--update)))
    (add-to-list 'global-mode-string '("" keycast-mode-line))
    (message "`keycast' loaded"))
#+end_src

** [[https://github.com/Kungsgeten/selected.el][Selected]]
:PROPERTIES:
:CUSTOM_ID: selected
:END:

#+begin_src emacs-lisp
  (use-package selected
    :init
    (require 'hide-region)
    (selected-global-mode)
    :general
    (:keymaps 'selected-keymap
              ;; "C-?"                     'hydra-selected/body
              "<"                       'mc/mark-previous-like-this
              ">"                       'mc/mark-next-like-this
              "C-<"                     'mc/unmark-previous-like-this
              "C->"                     'mc/unmark-next-like-this
              "M-<"                     'mc/skip-to-previous-like-this
              "M->"                     'mc/skip-to-next-like-this
              "C-c >"                   'mc/edit-lines
              "M-c"                     'capitalize-dwim
              "M-d"                     'downcase-dwim
              "M-u"                     'upcase-dwim
              "C-f"                     'fill-region
              "C-q"                     'selected-off
              "C-c s r"                 'reverse-region
              "C-c s s"                 'sort-lines
              "C-c s w"                 'pokemacs-sort-words
              "C-<return>"              'hide-region-hide
              "C-p"                     '("Pins the selected region on top of the current window" . hide-region-pin))
    :config (message "`selected' loaded"))
#+end_src

** DISABLED: [[https://github.com/emacsorphanage/god-mode][God mode]]
:PROPERTIES:
:CUSTOM_ID: disabled-god-mode
:END:

This mode allows to switch between a mode where modifier keys are not used (~C-key~ is replaced by ~key~ and ~M-key~ by ~g key~. However, in my current config I often have ~C-key key'~ bindings and I would need to rebind them to ~C-key C-key'~ to have a seemless experience with this mode and I didn't find the need for it as of now.

#+begin_src emacs-lisp
  (use-package god-mode
    :disabled
    :init
    (setq god-mode-enable-function-key-translation nil)
    :custom
    (god-exempt-major-modes nil)
    (god-exempt-predicates nil)
    :config
    (defun my-god-mode-update-modeline ()
      (cond (god-local-mode
             (progn
               (set-face-background 'mode-line "#e9e2cb")
               (set-face-foreground 'mode-line "black")
               (set-face-background 'mode-line-inactive "#e9e2cb")
               (set-face-foreground 'mode-line-inactive "black")))
            (t (progn
                 (set-face-background 'mode-line "#0a2832")
                 (set-face-foreground 'mode-line "white")
                 (set-face-background 'mode-line-inactive "#0a2832")
                 (set-face-foreground 'mode-line-inactive "white")))))
    (add-hook 'god-mode-enabled-hook #'my-god-mode-update-modeline)
    (add-hook 'god-mode-disabled-hook #'my-god-mode-update-modeline)
    :general
    (("<escape>"                'god-mode-all)
     ("²"                       'god-mode-all)
     ("C-²"                     'god-mode-all)))
#+end_src

* General Utilities
:PROPERTIES:
:CUSTOM_ID: general-utilities
:END:

This part will load packages that are useful for emacs and are not specific to modes (usually, better commands and buffer manipulations)

** Hydras for emacs
:PROPERTIES:
:CUSTOM_ID: hydras-for-emacs
:END:

#+begin_src emacs-lisp
  (use-package root-mode
    :ensure nil
    :mode-hydra
    ((:color pink :quit-key "q")
     ("Doc"
      (("i" info-lookup-symbol "info lookup")))))
#+end_src

** Kill ring doesn't kill text properties
:PROPERTIES:
:CUSTOM_ID: kill-ring-doesnt-kill-text-properties
:END:

#+begin_src emacs-lisp
  (defun pokemacs-unpropertize-kill-ring ()
    (setq kill-ring (mapcar 'substring-no-properties kill-ring)))

  (add-hook 'kill-emacs-hook #'pokemacs-unpropertize-kill-ring)
#+end_src

** Isearch/Query-replace
:PROPERTIES:
:CUSTOM_ID: isearchquery-replace
:END:

#+begin_src emacs-lisp
  (use-package emacs
    :demand t
    :ensure nil
    :general
    (:keymaps 'query-replace-map
              "M-c" 'pokemacs-toggle-case
              "c"   'pokemacs-toggle-case)
    :config

    (defadvice isearch-mode (around isearch-mode-default-string (forward &optional regexp op-fun recursive-edit word-p) activate)
      (if (and transient-mark-mode mark-active (not (eq (mark) (point))))
          (progn
            (isearch-update-ring (buffer-substring-no-properties (mark) (point)))
            (deactivate-mark)
            ad-do-it
            (if (not forward)
                (isearch-repeat-backward)
              (goto-char (mark))
              (isearch-repeat-forward)))
        ad-do-it))
    (defun pokemacs-toggle-case ()
      (interactive)
      (setq case-fold-search (not case-fold-search))
      (message "toggled case-fold-search to %s" case-fold-search))
    (defconst query-replace-help
      "Type \\`SPC' or \\`y' to replace one match, Delete or \\`n' to skip to next,
    \\`RET' or \\`q' to exit, Period to replace one match and exit,
    \\`,' to replace but not move point immediately,
    \\`C-r' to enter recursive edit (\\[exit-recursive-edit] to get out again),
    \\`C-w' to delete match and recursive edit,
    \\`C-l' to clear the screen, redisplay, and offer same replacement again,
    \\`!' to replace all remaining matches in this buffer with no more questions,
    \\`^' to move point back to previous match,
    \\`u' to undo previous replacement,
    \\`U' to undo all replacements,
    \\`e' to edit the replacement string.
    \\`E' to edit the replacement string with exact case.
    In multi-buffer replacements type \\`Y' to replace all remaining
    matches in all remaining buffers with no more questions,
    \\`N' to skip to the next buffer without replacing remaining matches
    in the current buffer.
    \\`c' or \\`M-c' to toggle case sensitivity"
      "Help message while in `query-replace'.")
    (message "`emacs' config loaded"))

#+end_src

** Cursor
:PROPERTIES:
:CUSTOM_ID: cursor
:END:

#+begin_src emacs-lisp
  (setopt cursor-in-non-selected-windows t) ; Hide the cursor in inactive windows
#+end_src

** [[https://github.com/emacsmirror/nlinum/blob/master/nlinum.el][Nlinum]]
:PROPERTIES:
:CUSTOM_ID: nlinum
:END:

#+begin_src emacs-lisp
  (use-package nlinum
    :init (global-nlinum-mode 1)
    :custom
    (nlinum--width (length (number-to-string (count-lines (point-min) (point-max)))))
    :config
    (message "`nlinum' loaded"))
#+end_src

** [[https://github.com/mykyta-shyrin/cheatsheet][Cheat Sheet]]
:PROPERTIES:
:CUSTOM_ID: cheat-sheet
:END:

When I have the time

#+begin_src emacs-lisp
  (use-package cheatsheet
    :config (message "`cheatsheet' loaded"))
#+end_src

** [[https://github.com/bbatsov/crux][Crux]]
:PROPERTIES:
:CUSTOM_ID: crux
:END:

Useful commands. Notably (not all of them are crux but we put them in the crux command map) :

- ~C-x K~: Kill all buffers except the active one
- ~M-m e~: Edit a file with sudo
- ~M-m u/d/c~: upcase/downcase/capitalize region or word at point


#+begin_src emacs-lisp
  (use-package crux
    :init
    (define-prefix-command 'pokemacs-crux-map nil "Crux-")
    :general
    ("M-m" 'pokemacs-crux-map)
    ("C-a" 'crux-move-beginning-of-line)
    ("C-x 4 t" 'crux-transpose-windows)
    ("C-x K" 'crux-kill-other-buffers)
    ("C-k" 'crux-smart-kill-line)
    (:keymaps 'pokemacs-crux-map
              "w" '("Open a new buffer containing the contents of URL." . crux-view-url)
              "o" '("Open visited file in default external program." . crux-open-with)
              "e" '("Edit currently visited file as root." . crux-sudo-edit)
              "i" '("Insert a timestamp according to locale's date and time format." . crux-insert-date)
              "t" '("Transpose the buffers shown in two windows." . crux-transpose-windows)
              "j" '("Join the current line with the line beneath it." . crux-top-join-line)
              "u" '("upcase region if a region is active or word at point." . upcase-dwim)
              "d" '("downcase region if a region is active or word at point." . downcase-dwim)
              "c" '("capitalize region if a region is active or word at point." . capitalize-dwim)
              "r" '("Byte-compile all your dotfiles again." . crux-recompile-init)
              "k" '("Kill to the end of the line and kill whole line on the next call." . crux-smart-kill-line)
              "M-k" '("Kill line backwards and adjust the indentation." . crux-kill-line-backwards)
              "a" '("Move point back to indentation/beginning (toggle) of line." . crux-move-beginning-of-line)
              "s" '("Call `ispell-word', then create an abbrev for it." . crux-ispell-word-then-abbrev)
              )
    :config
    (crux-with-region-or-buffer indent-region)
    (crux-with-region-or-buffer untabify)
    (crux-with-region-or-point-to-eol kill-ring-save)
    (defalias 'rename-file-and-buffer #'crux-rename-file-and-buffer)
    (message "`crux' loaded"))
#+end_src

** [[https://github.com/manateelazycat/delete-block][Delete block]]
:PROPERTIES:
:CUSTOM_ID: delete-block
:END:

Better block deletion.

#+begin_src emacs-lisp
  (use-package delete-block
    :load-path "lisp/"
    :ensure nil
    :general
    ("C-d"                     'delete-block-forward)
    ("C-<DEL>"           'delete-block-backward)
    ("M-<DEL>"           'delete-block-backward)
    :config (message "`delete-block' loaded"))
#+end_src

** [[https://framagit.org/steckerhalter/discover-my-major][Discover my major]]
:PROPERTIES:
:CUSTOM_ID: discover-my-major
:END:

#+begin_src emacs-lisp
  (use-package discover-my-major
    :general ("C-h C-m" 'discover-my-major)
    :config (message "`discover-my-major' loaded"))
#+end_src

** Helpful
:PROPERTIES:
:CUSTOM_ID: helpful
:END:

#+begin_src emacs-lisp
  (use-package helpful
    :general
    ([remap describe-key] 'helpful-key)
    ([remap describe-function] 'helpful-callable)
    ([remap describe-variable] 'helpful-variable)
    ([remap describe-symbol] 'helpful-symbol)
    ("C-c C-d" 'helpful-at-point)
    ("C-h F" 'helpful-function)
    ("C-h C" 'helpful-command))
#+end_src

** [[https://github.com/leoliu/easy-kill][Easy-kill]]
:PROPERTIES:
:CUSTOM_ID: easy-kill
:END:

Better ~M-w~

#+begin_src emacs-lisp
   (use-package easy-kill
     :general
     ([remap kill-ring-save] 'easy-kill)
     ([remap mark-sexp] 'easy-mark)
     :config
     (message "`easy-kill loaded"))
#+end_src

** JSON
:PROPERTIES:
:CUSTOM_ID: json
:END:

Library for parsing and generating JSON

#+begin_src emacs-lisp
  (use-package json
    :ensure nil
    :demand t
    :config
    (defun get-secrets-config-value (key)
      "Return the value of the json file secrets for key"
      (cdr (assoc key (json-read-file "~/.secrets/secrets.json"))))
    (message "`json' loaded"))
#+end_src

** Spell and grammar checking
:PROPERTIES:
:CUSTOM_ID: spell-and-grammar-checking
:END:

*** [[https://github.com/emacs-languagetool/lsp-ltex-plus][lsp-ltex-plus]]
:PROPERTIES:
:CUSTOM_ID: lsp-ltex-plus
:END:

#+begin_src emacs-lisp
  (use-package lsp-ltex-plus
    :ensure (:type git :host github :repo "emacs-languagetool/lsp-ltex-plus")
    :init (setopt lsp-ltex-plus-version "18.5.1")
    :custom
    (lsp-ltex-plus-language pokemacs-dict)
    (lsp-ltex-plus-status-bar-item t)
    ;; These rules are useless since we use jinx
    (lsp-ltex-plus-disabled-rules
     `(:en-US
       ,(vector
         "MORFOLOGIK_RULE_EN_GB"
         "HUNSPELL_RULE"
         "HUNSPELL_RULE_AR"
         "MORFOLOGIK_RULE_AST"
         "MORFOLOGIK_RULE_EN"
         "MORFOLOGIK_RULE_EN_US"
         "SYMSPELL_RULE")))
    :config (message "`lsp-ltex-plus' loaded"))
#+end_src

*** [[https://github.com/minad/jinx][Jinx]]
:PROPERTIES:
:CUSTOM_ID: jinx
:END:

You need to install ~libenchant-2-dev~ and ~pkgconf~.

#+begin_src emacs-lisp
  (use-package jinx
    ;; :ensure-system-package libenchant-2-dev
    :hook (emacs-startup . global-jinx-mode)
    :init
    (defconst aspell-dicts-dumps
      (file-name-as-directory (no-littering-expand-etc-file-name "aspell-dicts-dumps/")))

    ;; Create the aspell dictionaries dumps directory
    (unless (file-exists-p aspell-dicts-dumps)
      (make-directory aspell-dicts-dumps))

    ;; Dump dictionaries if they don't exist
    (defconst en-GB-dump (concat aspell-dicts-dumps "en_GB"))
    (defconst en-US-dump (concat aspell-dicts-dumps "en_US"))
    (defconst fr-FR-dump (concat aspell-dicts-dumps "fr_FR"))

    (defconst pokemacs-dict-constants
      `(("en_GB" . ,en-GB-dump)
        ("en_US" . ,en-US-dump)
        ("fr_FR" . ,fr-FR-dump)))

    (dolist (pair pokemacs-dict-constants)
      (let ((locale (car pair))
            (dump-file (cdr pair)))
        (unless (file-exists-p dump-file)
          (async-shell-command
           (concat "aspell --master=" locale " dump master > " dump-file)))))

    (defun pokemacs-get-dict-file ()
      (let ((pair (assoc pokemacs-dict pokemacs-dict-constants)))
        (when pair (cdr pair))))

    (defun pokemacs-change-dict ()
      (interactive)
      (pokemacs-customize-my-custom-variable "pokemacs-dict")
      (setq jinx-languages pokemacs-dict)
      (setq lsp-ltex-plus-language (replace-regexp-in-string "_" "-" pokemacs-dict))
      (setq cape-dict-file (pokemacs-get-dict-file)))

    :custom
    (jinx-languages pokemacs-dict)
    (cape-dict-file (pokemacs-get-dict-file))
    :general
    (:keymaps 'jinx-overlay-map
              "RET" 'jinx-correct)
    ("M-$"  'jinx-correct)
    ("C-M-$" 'pokemacs-change-dict)
    :config
    ;; Temporary setting tree-sitter faces for jinx-include-faces
    ;; When tuareg has a proper treesitter mode this will become useless
    (let* ((prog-faces (alist-get 'prog-mode jinx-include-faces))
           (new-prog-faces (cl-revappend prog-faces '(tree-sitter-hl-face:doc tree-sitter-hl-face:string tree-sitter-hl-face:comment))))
      (setf (alist-get 'prog-mode jinx-include-faces) new-prog-faces)))
#+end_src

** [[https://github.com/nschum/highlight-symbol.el][Highlight symbol]]
:PROPERTIES:
:CUSTOM_ID: highlight-symbol
:END:

Useful package that allows to go to the next and previous symbols at point with ~M-S-<down>~ and ~M-S-<up>~.

#+begin_src emacs-lisp
  (use-package highlight-symbol
    :demand t
    :hook (prog-mode . highlight-symbol-nav-mode)
    :general
    (:keymaps 'highlight-symbol-nav-mode-map
              "M-n" nil
              "M-p" nil)
    ("M-<f6>"       '("highlight the symbol at point" . highlight-symbol))
    ("M-S-<down>"   '("go to the next symbol" . highlight-symbol-next))
    ("M-S-<up>"     '("go to the previous symbol" . highlight-symbol-prev))
    :config
    (message "`highlight-symbol' loaded"))
#+end_src

** Moving
:PROPERTIES:
:CUSTOM_ID: moving
:END:

#+begin_src emacs-lisp
  (use-package emacs
    :ensure nil
    :general
    ("M-<up>" 'pokemacs-move-line-up)
    ("M-<down>" 'pokemacs-move-line-down)
    :config
    (defmacro pokemacs-save-column (&rest body)
      `(let ((column (current-column)))
         (unwind-protect
             (progn ,@body)
           (move-to-column column))))

    (put 'save-column 'lisp-indent-function 0)

    (defun pokemacs-move-line-up ()
      "Move up the current line."
      (interactive)
      (pokemacs-save-column
       (transpose-lines 1)
       (forward-line -2)
       (indent-according-to-mode)))

    (defun pokemacs-move-line-down ()
      "Move down the current line."
      (interactive)
      (pokemacs-save-column
       (forward-line 1)
       (transpose-lines 1)
       (forward-line -1)
       (indent-according-to-mode))))
#+end_src

** [[https://github.com/magnars/multiple-cursors.el][Multiple cursors]]
:PROPERTIES:
:CUSTOM_ID: multiple-cursors
:END:

Allows to have multiple cursors. There are a lot of functions provided by this mode but since I don't use this feature a lot I'd advise looking at the mode documentation. I mostly use it in conjunction with [[#selected][Selected]] (with ~>~, ~<~ and ~RET~).1

#+begin_src emacs-lisp
  (use-package multiple-cursors
    :general
    ("C-c n" 'mc/mark-next-like-this)
    ("C-c p" 'mc/mark-previous-like-this)
    ("C-c a" 'mc/mark-all-like-this)
    :config (message "`multiple-cursors' loaded"))
#+end_src

** TODO Hide region
:PROPERTIES:
:CUSTOM_ID: hide-region
:END:

TODO: hide-region-unpin doesn't work when changing buffer.

(The keybind for ~hide-region-pin~ is located in the [[#selected][Selected]] section)

#+begin_src emacs-lisp
  (use-package hide-region
    :load-path "lisp/"
    :ensure nil
    :commands hide-region-pin
    :general
    ("C-c r u" 'hide-region-unpin)
    :config (message "`hide-region' loaded"))
#+end_src

** [[https://github.com/hlissner/emacs-hide-mode-line][Hide mode line]]
:PROPERTIES:
:CUSTOM_ID: hide-mode-line
:END:

Used by some packages

#+begin_src emacs-lisp
  (use-package hide-mode-line
    :config (message "`hide-mode-line' loaded"))
#+end_src

** [[https://github.com/m00natic/vlfi][View Large Files]]
:PROPERTIES:
:CUSTOM_ID: view-large-files
:END:

#+begin_src emacs-lisp
  (use-package vlf
    :defer 2
    :config (require 'vlf-setup))
#+end_src

** [[https://github.com/casouri/vundo][Vundo]]
:PROPERTIES:
:CUSTOM_ID: vundo
:END:

#+begin_src emacs-lisp
  (use-package vundo
    :demand t
    :commands (vundo)
    :general
    ("C-x u" 'vundo)
    (:keymaps 'vundo-mode-map
              "u" 'vundo-backward)
    :custom
    (vundo-glyph-alist vundo-unicode-symbols)
    (vundo-compact-display t)
    :config
    (message "`vundo' loaded"))
#+end_src

** [[https://www.emacswiki.org/emacs/WhiteSpace][Whitespace]]
:PROPERTIES:
:CUSTOM_ID: whitespace
:END:

Simple mode to visualize blanks

#+begin_src emacs-lisp
  (use-package whitespace
    :ensure nil
    :hook
    (prog-mode . whitespace-mode)
    (text-mode . whitespace-mode)
    :custom
    (whitespace-style '(face empty indentation::space tab trailing))
    :config (message "`whitespace' loaded"))
#+end_src

** Window locking
:PROPERTIES:
:CUSTOM_ID: window-locking
:END:

#+begin_src emacs-lisp
  (define-minor-mode locked-window-buffer-mode
    "Make the current window always display this buffer."
    :lighter "locked"
    (set-window-dedicated-p (selected-window) locked-window-buffer-mode))

  (use-package locked-window-buffer-mode
    :ensure nil
    :general ("M-l l"    'locked-window-buffer-mode))
#+end_src

* Process management
:PROPERTIES:
:CUSTOM_ID: process-management
:END:

** Proced
:PROPERTIES:
:CUSTOM_ID: proced
:END:

#+begin_src emacs-lisp
  (use-package proced
    :ensure nil
    :commands proced
    :custom
    (proced-auto-update-flag t)
    (proced-auto-update-interval 5)
    (proced-goal-attribute nil)
    (proced-show-remote-processes t)
    (proced-enable-color-flag t)
    (proced-format 'custom)
    :config
    (setq pokemacs-proced-important-executables-regex (regexp-opt pokemacs-proced-important-executables))
    (defun pokemacs--proced-format-args-names-only (args)
      "Format attribute ARGS.
    Replace newline characters by \"^J\" (two characters)."
      (pcase-let* ((exe (f-base args))
                   (exe (proced-format-args exe))
                   (`(,exe . _args) (split-string exe))
                   (exe (string-trim exe "[\\]+" "[\\]+"))
                   (exe-prop
                    (if (string-match-p exe pokemacs-proced-important-executables-regex)
                        (propertize exe 'font-lock-face 'pokemacs-proced-important-executable)
                      exe)))
        exe-prop))
    (defface pokemacs-proced-important-executable '((t :inherit proced-executable :weight bold))
      "font face for important executables."
      :group 'my-mode)
    (setf (alist-get 'args proced-grammar-alist)
          '("Args"               ; name of the column
            pokemacs--proced-format-args-names-only  ; format function
            left                 ; alignment within column
            proced-string-lessp  ; defines the sort method (ascending)
            nil                  ; non-nil reverses sort order
            (args pid)           ; sort scheme
            (nil t nil)))        ; refiner for custom refinement logic - see proced-refine
    (add-to-list
     'proced-format-alist
     '(custom user pid ppid sess tree pcpu pmem rss state args)))
#+end_src

* Dired/Shell
:PROPERTIES:
:CUSTOM_ID: diredshell
:END:

** Dired
:PROPERTIES:
:CUSTOM_ID: dired
:END:

#+begin_src emacs-lisp
  (use-package dired
    :ensure nil
    :general
    (:keymaps 'dired-mode-map
              "DEL" 'dired-up-directory))
#+end_src

** [[https://github.com/alexluigit/dirvish/][Dirvish]]
:PROPERTIES:
:CUSTOM_ID: dirvish
:END:

*** Main mode
:PROPERTIES:
:CUSTOM_ID: main-mode
:END:

#+begin_src emacs-lisp
  (use-package dirvish
    :ensure (dirvish :files (:defaults "extensions/*"))
    :hook (dirvish-directory-view-mode . (lambda () (nlinum-mode 0)))
    :init
    (dirvish-override-dired-mode)
    :custom
    ;; From doomemacs/blob/master/modules/emacs/dired/config.el#L84C1-L89C35
    ;; Don't recycle sessions. We don't want leftover buffers lying around,
    ;; especially if users are reconfiguring Dirvish or trying to recover from an
    ;; error. It's too easy to accidentally break Dirvish (e.g. by focusing the
    ;; header window) at the moment, or get stuck in a focus loop with the buried
    ;; buffers. Starting from scratch isn't even that expensive, anyway.
    ;; (dirvish-default-layout '(1 0.11 nil))
    (dirvish-reuse-session nil)
    (dirvish-attributes '(nerd-icons file-time file-size collapse subtree-state vc-state))
    (dirvish-side-attributes '(vc-state file-size nerd-icons collapse))
    (dirvish-mode-line-format '(:left (sort file-time symlink) :right (omit yank index)))
    (dirvish-subtree-always-show-state t)
    (dirvish-hide-details '(dirvish dirvish-side))
    (dirvish-hide-cursor '(dirvish dirvish-side))
    (delete-by-moving-to-trash t)
    (dired-listing-switches
     "-l --almost-all --human-readable --group-directories-first --no-group")
    ;; (dirvish-quick-access-entries ; It's a custom option, `setq' won't work
    ;;  '(("h" "~/"                          "Home")
    ;;    ("d" "~/Downloads/"                "Downloads")
    ;;    ("m" "/mnt/"                       "Drives")
    ;;    ("t" "~/.local/share/Trash/files/" "TrashCan")))
    :general ; Bind `dirvish-fd|dirvish-side|dirvish-dwim' as you see fit
    ("C-c f" 'dirvish)
    (:keymaps 'dirvish-mode-map          ; Dirvish inherits `dired-mode-map'
              "?"   'dirvish-dispatch     ; contains most of sub-menus in dirvish extensions
              "a"   'dirvish-quick-access
              "f"   'dirvish-file-info-menu
              "y"   'dirvish-yank-menu
              "N"   'dirvish-narrow
              "^"   'dirvish-history-last
              "h"   'dirvish-history-jump ; remapped `describe-mode'
              "s"   'dirvish-quicksort    ; remapped `dired-sort-toggle-or-edit'
              "v"   'dirvish-vc-menu      ; remapped `dired-view-file'
              "TAB" 'dirvish-subtree-toggle
              "M-f" 'dirvish-history-go-forward
              "M-b" 'dirvish-history-go-backward
              "M-l" 'dirvish-ls-switches-menu
              "M-m" 'dirvish-mark-menu
              "M-t" 'dirvish-layout-toggle
              "M-r" 'dirvish-setup-menu
              "M-e" 'dirvish-emerge-menu
              "M-j" 'dirvish-fd-jump)
    :config
    (message "`dirvish' loaded"))
#+end_src

*** Extensions
:PROPERTIES:
:CUSTOM_ID: extensions
:END:

#+begin_src emacs-lisp
  (use-package dirvish-icons
    :ensure nil)
#+end_src

** Dwim shell commands
:PROPERTIES:
:CUSTOM_ID: dwim-shell-commands
:END:

#+begin_src emacs-lisp
  (use-package dwim-shell-command
    :ensure (dwim-shell-command :files (:defaults "*.el"))
    :general
    ([remap shell-command]   'dwim-shell-command)
    (:keymaps 'dired-mode-map
              [remap dired-do-async-shell-command] 'dwim-shell-command
              [remap dired-do-shell-command]       'dwim-shell-command
              [remap dired-smart-shell-command]    'dwim-shell-command)
    :config (require 'dwim-shell-commands))
#+end_src

* Git
:PROPERTIES:
:CUSTOM_ID: git
:END:

** Cond-let
:PROPERTIES:
:CUSTOM_ID: cond-let
:END:

#+begin_src emacs-lisp
  (use-package cond-let
    :ensure (:host github :repo "tarsius/cond-let"))
#+end_src

** [[https://magit.vc/][Magit]]
:PROPERTIES:
:CUSTOM_ID: magit
:END:

#+begin_src emacs-lisp
  (use-package transient)

  (use-package magit
    :general
    ("C-c g"  'magit-file-dispatch)
    ("M-v"    '(:keymap magit-mode-map :package magit :wk "Magit-:"))
    ("M-n"    'pokemacs-smerge-or-flycheck-next)
    (:keymaps 'smerge-mode-map
              "M-m"                 'smerge-keep-mine
              "M-o"                 'smerge-keep-other)
    (:keymaps 'magit-mode-map
              "g"             'magit-status
              "G"             'git-messenger:popup-message
              "M-g"           'magit-dispatch)
    :init
    (pretty-hydra-define
      hydra-smerge (:title "Smerge" :hint nil :quit-key "q")
      (
       "Resolve Conflict"
       (("m" smerge-keep-upper "Keep Upper")
        ("o" smerge-keep-lower "Keep Lower")
        ("a" smerge-keep-all "Keep All")
        ("r" smerge-resolve "Auto")
        ("e" smerge-ediff "Ediff"))

       "Navigation"
       (("n" smerge-vc-next-conflict "Next")
        ("p" smerge-prev "Previous")
        ("s" smerge-start-session "Start"))

       "Utility"
       (("c" git-messenger:popup-message "Commit at point M-v G"))))
    :custom
    (magit-bury-buffer-function 'magit-restore-window-configuration)
    (magit-auto-revert-mode t)
    (magit-auto-revert-immediately t)
    (magit-format-file-function #'magit-format-file-nerd-icons)
    :config
    (transient-suffix-put 'magit-push "-u" :level 1)
    (defun pokemacs-smerge-or-flycheck-next ()
      (interactive)
      (let (files (vc-git-conflicted-files default-directory))
        (if (null files)
            (flycheck-next-error)
          (smerge-vc-next-conflict))))
    (message "`magit' loaded"))
#+end_src

** [[https://github.com/dandavison/magit-delta][Magit delta]]
:PROPERTIES:
:CUSTOM_ID: magit-delta
:END:

Make sure [[https://github.com/dandavison/delta][delta]] is installed.

#+begin_src emacs-lisp
  (when use-delta
    (use-package magit-delta
    :hook (magit-mode . magit-delta-mode)
    :config
    (setenv "DELTA_FEATURES" "+")
    (setq magit-delta-delta-args (append magit-delta-delta-args '("--features" "magit-delta")))))
#+end_src

** [[https://github.com/alphapapa/magit-todos][Magit todos]]
:PROPERTIES:
:CUSTOM_ID: magit-todos
:END:

Adds a list of TODOS and other keywords (that can be found with ~M-h v magit-todos-keywords-list~). If you experience massive freezing when opening a magit buffer you can customize ~hl-todo-keywords-faces~ to only include your custom keywords.

#+begin_src emacs-lisp
  (when use-magit-todos
    (use-package magit-todos
      :hook (magit . magit-todos)
      :custom
      (magit-todos-keywords-list (-mapcat (lambda (assoc) (list (car assoc))) hl-todo-keyword-faces))
      :config
      (message "`magit-todos' loaded")))
#+end_src

** Ediff
:PROPERTIES:
:CUSTOM_ID: ediff
:END:

#+begin_src emacs-lisp
  (use-package ediff
    :ensure nil
    :custom
    (ediff-split-window-function 'split-window-horizontally)
    (ediff-window-setup-function 'ediff-setup-windows-plain)
    :config
    (require 'magit-diff)
    (custom-set-faces
     `(ediff-current-diff-A ((t (:weight normal :background ,(face-background 'magit-diff-removed-highlight)))))
     `(ediff-current-diff-B ((t (:weight normal :background ,(face-background 'magit-diff-added-highlight)))))
     `(ediff-even-diff-A ((t (:weight normal :background ,(face-background 'magit-diff-context-highlight)))))
     `(ediff-even-diff-B ((t (:weight normal :background ,(face-background 'magit-diff-added-highlight)))))
     `(ediff-fine-diff-A ((t (:inherit 'diff-refine-removed :weight normal))))
     `(ediff-fine-diff-B ((t (:inherit 'diff-refine-added :weight normal))))))
#+end_src

** [[https://github.com/tarsius/hl-todo][Highlight todo]]
:PROPERTIES:
:CUSTOM_ID: highlight-todo
:END:

Customize ~hl-todo-keyword-faces~ to choose the keywords you want to highlights (an example is already available in [[file:custom.el][custom.el]])

#+begin_src emacs-lisp
  (use-package hl-todo
    :ensure (:depth nil)
    :init (global-hl-todo-mode 1)
    :config (message "`hl-todo' loaded"))
#+end_src

** [[https://github.com/emacsorphanage/git-messenger][Git messenger]]
:PROPERTIES:
:CUSTOM_ID: git-messenger
:END:

Show the commit at point to see what happened here. Invoke with ~M-v G~.

#+begin_src emacs-lisp
  (use-package git-messenger
    :custom
    (git-messenger:show-detail t)
    (git-messenger:use-magit-popup t)
    :config
    (message "`git-messenger' loaded"))
#+end_src

** TODO [[https://github.com/emacsmirror/git-timemachine][Git timemachine]]
:PROPERTIES:
:CUSTOM_ID: git-timemachine
:END:

Go back in time with ~M-v <left>~ then travel through commits with ~p~, ~n~ and other commands listed in the package documentation.

TODO: Display possible commands when git-timemachine starts

#+begin_src emacs-lisp
  (use-package git-timemachine
    :config (message "`git-timemachine' loaded"))
#+end_src

** [[https://github.com/magit/git-modes/][Git modes]]
:PROPERTIES:
:CUSTOM_ID: git-modes
:END:

Major modes for editing .gitignore files, .git/config etc

#+begin_src emacs-lisp
  (use-package git-modes
    :config (message "`git-modes' loaded"))
#+end_src

** [[https://github.com/wandersoncferreira/code-review][Code review]]
:PROPERTIES:
:CUSTOM_ID: code-review
:END:

Some configuration is needed for this to work. See [[file:README.org::#git-hosts-and-forges][README.org Git hosts and forges]]

#+begin_src emacs-lisp
  (use-package code-review
    :after (magit forge)
    :ensure (code-review :type git :repo "git@github.com:ArthurHeymans/code-review.git" :branch "Emacs30ClosqlCompat")
    :custom
    (code-review-download-dir (no-littering-expand-var-file-name "backups/"))
    :config
    (message "`code-review' loaded"))
#+end_src

** [[https://github.com/isamert/lab.el][Lab]]
:PROPERTIES:
:CUSTOM_ID: lab
:END:

Some configuration is needed for this to work. See [[file:README.org::#git-hosts-and-forges][README.org Git hosts and forges]]

#+begin_src emacs-lisp
  (use-package lab
    :ensure (lab
             :type git :repo "https://github.com/isamert/lab.el.git")
    :config
    (message "`lab' loaded"))

#+end_src

** [[https://github.com/magit/forge][Forge]]
:PROPERTIES:
:CUSTOM_ID: forge
:END:

Some configuration is needed for this to work. See [[file:README.org::#git-hosts-and-forges][README.org Git hosts and forges]]

#+begin_src emacs-lisp
  (use-package forge
    :after magit
    :config
    (setq auth-sources '("~/.authinfo"))
    (message "`forge' loaded"))
#+end_src

** [[https://github.com/magit/ghub][Ghub]]
:PROPERTIES:
:CUSTOM_ID: ghub
:END:

#+begin_src emacs-lisp
  (use-package ghub
    :config (message "`ghub' loaded"))
#+end_src

* [[https://orgmode.org/][Org mode]]
:PROPERTIES:
:CUSTOM_ID: org-mode
:END:

Org mode is, well, org mode.

** Main mode
:PROPERTIES:
:CUSTOM_ID: main-mode-0
:END:

#+begin_src emacs-lisp
  (use-package ox-pandoc)

  (use-package ox
    :ensure nil
    :mode ("\\.org\\'" . org-mode)
    :init
    (defun pokemacs-filter-timestamp (trans back _comm)
      "Remove <> around time-stamps."
      (pcase back
        (`html
         (replace-regexp-in-string "&[lg]t;" "" trans))
        (`latex
         (replace-regexp-in-string "[<>]" "" trans))))

    :config
    (add-to-list 'org-export-filter-timestamp-functions #'pokemacs-filter-timestamp)
    (message "`ox' loaded"))

  (use-package mixed-pitch
    :config (message "`mixed-pitch' loaded"))

  ;; Install org from its git-repo if use-org is t
  ;; Otherwise, use the one provided by emacs
  (if use-org
      (use-package org)
    (use-package org
      :ensure nil))

  (use-package org
    :mode ("\\.org\\'" . org-mode)
    :ensure nil
    :hook
    (org-mode . mixed-pitch-mode)
    (org-mode . pokemacs-org-mode-hook)
    :general
    ("M-o" 'pokemacs-org-map)
    ("C-x C-p" 'pokemacs-org-compile-latex-and-update-other-buffer)
    ("C-c o l" 'pokemacs-logger)
    (:keymaps 'pokemacs-org-map
              "l"                       'org-store-link
              "a"                       'org-agenda
              "c"                       'org-capture)
    (:keymaps 'org-mode-map
              "M-j"                     'org-goto
              "C-c C-a"                 nil
              "C-<return>"              'org-meta-return
              "M-C-<return>"            'org-insert-heading-respect-content)
    (:keymaps 'org-src-mode-map
              "C-c C-c"                 'org-edit-src-exit)

    :init
    ;; Load personal configuration for org mode
    (add-hook 'elpaca-after-init-hook
              (lambda ()
                (let ((file (expand-file-name "~/.secrets/org.el")))
                  (when (file-exists-p file)
                    (load-file file)
                    (message "%S loaded" file)))))
    (general-unbind org-mode-map "M-h")
    (defun pokemacs-logger ()
      (interactive)
      "Print logger"
      (let ((line (number-to-string (line-number-at-pos))))
        (kill-new (concat buffer-file-name "::" line))))

    (defun pokemacs-org-mode-hook ()
      (let ((oldmap (cdr (assoc 'lsp-mode minor-mode-map-alist)))
            (newmap (make-sparse-keymap)))
        (set-keymap-parent newmap oldmap)
        (define-key newmap (kbd "C-c C-l") 'org-insert-link)
        (make-local-variable 'minor-mode-overriding-map-alist)
        (push `(lsp-mode . ,newmap) minor-mode-overriding-map-alist)))

    (defun pokemacs-org-compile-latex-and-update-other-buffer ()
      "Has as a premise that it's run from an org-mode buffer and the
                 other buffer already has the PDF open"
      (interactive)
      (org-latex-export-to-pdf)
      (pokemacs-update-other-buffer))

    :custom
    ;; Change this value to point to where your org files are
    (org-directory "~/org/")
    (org-list-allow-alphabetical t)
    ;; Babel
    (org-confirm-babel-evaluate nil)
    (org-insert-heading-respect-content nil)
    (org-special-ctrl-a/e t)
    (org-src-fontify-natively t)
    (org-src-tab-acts-natively t)
    (org-hide-block-startup t)
    ;; If you don't want the agenda in french you can comment the following
    ;; expression. You can even set it to your preferred language
    ;; https://www.emacswiki.org/emacs/CalendarLocalization#toc16
    (calendar-week-start-day 1)
    (calendar-day-name-array ["Dimanche" "Lundi" "Mardi" "Mercredi"
                              "Jeudi" "Vendredi" "Samedi"])
    (calendar-month-name-array ["Janvier" "Février" "Mars" "Avril" "Mai"
                                "Juin" "Juillet" "Août" "Septembre"
                                "Octobre" "Novembre" "Décembre"])
    ;; Rest
    (org-ellipsis " ▾")
    (org-startup-indented t)
    (org-adapt-indentation nil)
    (org-agenda-span 'week)
    (org-agenda-start-day "1d")
    (org-agenda-start-on-weekday nil)
    (org-agenda-start-with-log-mode t)
    (org-cycle-separator-lines -1)
    (org-fontify-done-headline t)
    (org-footnote-auto-adjust t)
    (org-hide-emphasis-markers t)
    (org-hide-leading-stars nil)
    (org-hide-macro-markers t)
    (org-image-actual-width '(300))
    (org-image-align 'center)
    (org-latex-compiler "xelatex")
    (org-log-done 'time)
    (org-odd-levels-only nil)
    (org-pretty-entities t)
    (org-src-fontify-natively t)
    (org-src-tab-acts-natively t)
    (org-startup-truncated nil)
    (org-startup-with-inline-images t)
    (org-support-shift-select 'always)
    (org-roam-v2-ack t) ; anonying startup message
    (org-todo-keywords
     '((sequence "TODO(t)" "PLANNING(p)" "IN-PROGRESS(i@/!)" "VERIFYING(v!)" "BLOCKED(b@)"  "|" "DONE(d!)" "OBE(o@!)" "WONT-DO(w@/!)" )
       ))
    (org-image-actual-width nil)
    (org-agenda-custom-commands
     '(("r" "Rendez-vous" agenda* "Rendez-vous du mois"
        ((org-agenda-span 'month)
         (org-agenda-show-all-dates nil)))))
    :config
    ;; TODO states
    (define-prefix-command 'pokemacs-org-map nil "Org-")
    (customize-set-value 'org-latex-with-hyperref nil)
    (add-to-list 'org-latex-default-packages-alist "\\PassOptionsToPackage{hyphens}{url}")

    (defun org-mode-<>-syntax-fix (start end)
      "Change syntax of characters ?< and ?> to symbol within source code blocks."
      (let ((case-fold-search t))
        (when (eq major-mode 'org-mode)
          (save-excursion
            (goto-char start)
            (while (re-search-forward "<\\|>" end t)
              (when (save-excursion
                      (and
                       (re-search-backward "[[:space:]]*#\\+\\(begin\\|end\\)_src\\_>" nil t)
                       (string-equal (downcase (match-string 1)) "begin")))
                ;; This is a < or > in an org-src block
                (put-text-property (point) (1- (point))
                                   'syntax-table (string-to-syntax "_"))))))))

    (defun org-setup-<>-syntax-fix ()
      "Setup for characters ?< and ?> in source code blocks.
              Add this function to `org-mode-hook'."
      (setq syntax-propertize-function 'org-mode-<>-syntax-fix)
      (syntax-propertize (point-max)))

    (add-hook 'org-mode-hook #'org-setup-<>-syntax-fix)

    (calendar-set-date-style 'iso)

    (org-babel-do-load-languages
     'org-babel-load-languages
     '(
       (dot . t)
       (emacs-lisp . t)
       (latex . t)
       (ocaml . t)
       (shell . t)))
    (add-hook 'org-mode-hook
              (lambda ()
                (push '("- [ ]" . "") prettify-symbols-alist)
                (push '("+ [ ]" . "") prettify-symbols-alist)
                (push '("* [ ]" . "") prettify-symbols-alist)
                (push '("- [X]" . "") prettify-symbols-alist)
                (push '("+ [X]" . "") prettify-symbols-alist)
                (push '("* [X]" . "") prettify-symbols-alist)
                (push '("- [-]" . "") prettify-symbols-alist)
                (push '("+ [-]" . "") prettify-symbols-alist)
                (push '("* [-]" . "") prettify-symbols-alist)
                (prettify-symbols-mode)))
    (message "`org-mode' loaded"))

  (use-package org-protocol
    :demand t
    :ensure nil
    :init
    (defun transform-square-brackets-to-round-ones(string-to-transform)
      "Transforms [ into ( and ] into ), other chars left unchanged."
      (concat
       (mapcar #'(lambda (c) (if (equal c ?\[) ?\( (if (equal c ?\]) ?\) c))) string-to-transform)))
    :custom
    (org-capture-templates
     `(
       ("t" "Task" entry (file+headline ,(concat org-directory "agenda.org") "Calendrier")
        "* TODO %?\n  %u\n  %a")
       ("s" "Scheduled" entry (file+headline ,(concat org-directory "agenda.org") "Calendrier")
        "* TODO %?\n SCHEDULED: %^t \n %a")
       ("p" "Protocol" entry (file+headline ,(concat org-directory "notes.org") "Inbox")
        "* %^{Title}\nSource: %u, %c\n #+BEGIN_QUOTE\n%i\n#+END_QUOTE\n\n\n%?")
       ("L" "Protocol Link" entry (file+headline ,(concat org-directory "notes.org") "Inbox")
        "* %? [[%:link][%(transform-square-brackets-to-round-ones \"%:description\")]]\n")))
    :config (message "`org-protocol' loaded"))
#+end_src

** [[https://github.com/minad/org-modern][Org modern]]
:PROPERTIES:
:CUSTOM_ID: org-modern
:END:

#+begin_src emacs-lisp
  (use-package org-modern
    :after org
    :init (global-org-modern-mode)
    :custom
    (org-modern-star '("" "" "" "" "" "" ""))
    (org-modern-progress '("○" "◔" "◐" "◕" "●"))
    (org-modern-block-fringe 3)
    :config
    (custom-theme-set-faces
     'user
     '(org-modern-statistics ((t (:height 1.6)))))
    (message "`org-modern' loaded"))
#+end_src

** Graphviz-dot-mode
:PROPERTIES:
:CUSTOM_ID: graphviz-dot-mode
:END:

#+begin_src emacs-lisp
  (when use-org
    (use-package graphviz-dot-mode))
#+end_src

** [[https://github.com/yilkalargaw/org-auto-tangle][Org auto tangle]]
:PROPERTIES:
:CUSTOM_ID: org-auto-tangle
:END:

#+begin_src emacs-lisp
  (use-package org-auto-tangle
    :hook (org-mode . org-auto-tangle-mode)
    :config (message "`org-auto-tangle' loaded"))
#+end_src

** DISABLED [[httDps://github.com/jkitchin/org-ref][Org ref]]
:PROPERTIES:
:CUSTOM_ID: disabled-org-ref
:END:
:PROPERTIES:

Not using it anymore since I don't write articles but it may be useful

:CUSTOM_ID: org-ref
:END:
#+begin_src emacs-lisp
  (use-package org-ref
    :disabled
    :after org
    :init
    (setq org-ref-completion-library 'org-ref-ivy-cite)
    ;; :custom
    ;; (org-latex-pdf-process (list "latexmk -xelatex -shell-escape -bibtex -f -pdf %f"))
    )
#+end_src

** [[https://github.com/shg/org-inline-pdf.el][Org inline pdf]]
:PROPERTIES:
:CUSTOM_ID: org-inline-pdf
:END:

See pdf inlined when included in org files.

#+begin_src emacs-lisp
  (use-package org-inline-pdf
    :ensure-system-package pdf2svg
    :hook (org-mode . org-inline-pdf-mode)
    :config (message "`org-inline-pdf' loaded"))
#+end_src

** [[https://github.com/kiwanami/emacs-calfw][Calfw]]
:PROPERTIES:
:CUSTOM_ID: calfw
:END:

Calendar view in emacs buffer.

#+begin_src emacs-lisp
  (use-package calfw
    :ensure (calfw :files ("calfw-org.el" "calfw.el"))
    :custom
    (cfw:fchar-junction ?╋)
    (cfw:fchar-vertical-line ?┃)
    (cfw:fchar-horizontal-line ?━)
    (cfw:fchar-left-junction ?┣)
    (cfw:fchar-right-junction ?┫)
    (cfw:fchar-top-junction ?┯)
    (cfw:fchar-top-left-corner ?┏)
    (cfw:fchar-top-right-corner ?┓)
    :config (message "`calfw' loaded"))
#+end_src

** [[https://github.com/kiwanami/emacs-calfw][Calfw org]]
:PROPERTIES:
:CUSTOM_ID: calfw-org
:END:

This package allows to see the org calendar and adds a capture template for scheduling.

#+begin_src emacs-lisp
  (use-package calfw-org
    :after calfw
    :ensure nil
    :init
    (define-prefix-command 'pokemacs-calfw-map nil "Cal-")
    :general
    ("M-C" 'pokemacs-calfw-map)
    (:keymaps 'pokemacs-calfw-map
              "c" 'cfw:open-calendar-buffer
              "o" 'cfw:open-org-calendar)
    (:keymaps 'cfw:calendar-mode-map
              "RET" 'cfw:org-open-agenda-day)
    :custom
    (cfw:org-capture-template
     `("c" "calfw2org" entry (file+headline ,(concat org-directory "agenda.org") "Calendrier")
       "* %?\nSCHEDULED: %(cfw:org-capture-day)" :empty-lines 1))
    (cfw:org-overwrite-default-keybinding t)
    :config
    (defun cfw:org-capture-day ()
      (with-current-buffer  (get-buffer-create cfw:calendar-buffer-name)
        (let ((pos (cfw:cursor-to-nearest-date)))
          (concat "<"
                  (format-time-string  "%Y-%m-%d %a 09:00"
                                       (encode-time 0 0 0
                                                    (calendar-extract-day pos)
                                                    (calendar-extract-month pos)
                                                    (calendar-extract-year pos)))
                  ">"))))
    (message "`calfw-org' loaded"))
#+end_src

** [[https://github.com/myuhe/org-gcal.el][Org gcal]]
:PROPERTIES:
:CUSTOM_ID: org-gcal
:END:

If I have to reuse a Google calendar I may enable this package again but I don't need it right now.

#+begin_src emacs-lisp
  ;; The request can be wrong depending on Google updates, evaluate this:
  ;; (concat org-gcal-auth-url
  ;;         "?client_id=" (url-hexify-string org-gcal-client-id)
  ;;         "&response_type=code"
  ;;         "&redirect_uri=" (url-hexify-string "urn:ietf:wg:oauth:2.0:oob")
  ;;         "&scope=" (url-hexify-string org-gcal-resource-url))

  (when use-gcal
    (use-package plstore
      :ensure nil
      :custom
      (plstore-cache-passphrase-for-symmetric-encryption t)
      :config
      (add-to-list 'plstore-encrypt-to (get-secrets-config-value 'org-gcal-client-id)))

    (use-package org-gcal
      :custom
      (org-gcal-client-id (get-secrets-config-value 'org-gcal-client-id))
      (org-gcal-client-secret (get-secrets-config-value 'org-gcal-client-secret))
      (org-gcal-fetch-file-alist
       `(
         ;; (,(get-secrets-config-value 'calendar-company) . "~/org/calendar_company.org")
         (,(get-secrets-config-value 'calendar-user) . "~/org/calendar_user.org")))
      (message "`org-gcal' loaded")))
#+end_src

** [[https://github.com/alphapapa/org-super-agenda][Org super agenda]]
:PROPERTIES:
:CUSTOM_ID: org-super-agenda
:END:

Better agenda view for ~org-agenda~

#+begin_src emacs-lisp
  (use-package org-super-agenda
    :custom
    (org-super-agenda-groups
     '(;; Each group has an implicit Boolean OR operator between its selectors.
       (:name "Rendez-vous"  ; Optionally specify section name
              :time-grid t  ; Items that appear on the time grid
              )
       ;; After the last group, the agenda will display items that didn't
       ;; match any of these groups, with the default order position of 99
       ))
    :config
    (org-super-agenda-mode)
    (when use-org-agenda-startup (org-agenda nil "a"))
    (message "`org-super-agenda' loaded"))
#+end_src

** [[https://github.com/awth13/org-appear][Org appear]]
:PROPERTIES:
:CUSTOM_ID: org-appear
:END:

Like unprettify at point but for org invisible elements (links etc)

#+begin_src emacs-lisp
  (use-package org-appear
    :after org
    :ensure (org-appear :host github :repo "awth13/org-appear" :branch "org-9.7-fixes")
    :hook (org-mode . (lambda () (org-appear-mode 1)))
    :custom
    (org-appear-autolinks t)
    (org-appear-autoemphasis t)
    :config
    (message "`org-appear loaded"))
#+end_src

** [[https://github.com/org-roam/org-roam][Org roam]]
:PROPERTIES:
:CUSTOM_ID: org-roam
:END:

The next package I need to use fully, just starting right now.

#+begin_src emacs-lisp
  (when use-org-roam
    (use-package org-roam
      :after org
      :custom
      (org-roam-directory (file-truename "~/org/org-roam"))
      (org-roam-capture-templates
       '(
         ("a" "article" plain
          "\n* Source\n\nAuteur: %^{Author}\nTitre: ${title}\nAnnée: %^{Year}\nLien: %^{Link}\n\n* Résumé\n\n%?"
          :if-new (file+head "article/%<%Y%m%d%H%M%S>-${slug}.org" "#+title: ${title}\n#+filetags: :article:\n#+date: %U\n")
          :unnarrowed t)
         ("d" "default" plain
          "%?"
          :if-new (file+head "defaut/%<%Y%m%d%H%M%S>-${slug}.org" "#+title: ${title}\n#+filetags: :defaut:\n#+date: %U\n")
          :unnarrowed t)
         ("b" "livre" plain
          "\n* Source\n\nAuteur: %^{Author}\nTitre: ${title}\nAnnée: %^{Year}\n\n* Résumé\n\n%?"
          :if-new (file+head "art/livre/%<%Y%m%d%H%M%S>-${slug}.org" "#+title: ${title}\n#+filetags: :art::livre:\n#+date: %U\n")
          :unnarrowed t)
         ("f" "film" plain
          "\n* Source\n\nRéalisateur: %^{Author}\nTitre: ${title}\nAnnée: %^{Year}\n\n* Résumé\n\n%?"
          :if-new (file+head "art/cinema/%<%Y%m%d%H%M%S>-${slug}.org" "#+title: ${title}\n#+filetags: :art::film:\n#+date: %U\n")
          :unnarrowed t)
         ("i" "informatique" plain "%?"
          :if-new
          (file+head "science/informatique/%<%Y%m%d%H%M%S>-${slug}.org.org" "#+title: ${title}\n#+filetags: :informatique:\n#+date: %U\n")
          :immediate-finish t
          :unnarrowed t)
         ("l" "langage" plain
          "* Characteristics\n\n- Famille: %?\n- Inspirations: \n\n* Référence:\n\n"
          :if-new (file+head "science/informatique/langages/${title}.org" "#+title: ${title}\n#+filetags: :langage:\n#+date: %U\n")
          :unnarrowed t)
         ("p" "projet" plain
          "* Objectifs\n\n%?\n\n* Tâches\n\n** TODO Ajouter de nouvelles tâches\n\n* Dates\n\n"
          :if-new (file+head "projets/%<%Y%m%d%H%M%S>-${slug}.org" "#+title: ${title}\n#+filetags: :projet:")
          :unnarrowed t)
         ("s" "sciences" plain "%?"
          :if-new
          (file+head "sciences/${title}.org" "#+title: ${title}\n#+filetags: :sciences:\n#+filetags: :science:#+date: %U\n")
          :immediate-finish t
          :unnarrowed t)))
      :general
      (:keymaps 'pokemacs-org-map
                "r" 'org-roam-buffer-toggle
                "f" 'org-roam-node-find
                "g" 'org-roam-graph
                "i" 'org-roam-node-insert
                "c" 'org-roam-capture
                ;; Dailies
                "j" 'org-roam-dailies-capture-today)
      :custom
      (org-roam-node-display-template (concat "${title:*} " (propertize "${tags:10}" 'face 'org-tag)))
      (org-roam-node-display-template
       (concat "${type:15} ${title:*} " (propertize "${tags:10}" 'face 'org-tag)))
      :config
      ;; If you're using a vertical completion framework, you might want a more informative completion interface

      (org-roam-db-autosync-mode)

      (cl-defmethod org-roam-node-type ((node org-roam-node))
        "Return the TYPE of NODE."
        (condition-case nil
            (file-name-nondirectory
             (directory-file-name
              (file-name-directory
               (file-relative-name (org-roam-node-file node) org-roam-directory))))
          (error "")))



      ;; If using org-roam-protocol
      (require 'org-roam-protocol)
      (message "`org-roam' loaded"))

    (use-package org-roam-ui
      :after org-roam
      :custom
      (org-roam-ui-sync-theme t)
      (org-roam-ui-follow t)
      (org-roam-ui-update-on-save t)
      (org-roam-ui-open-on-start t)
      :config
      (message "`org-roam-ui' loaded")))
#+end_src

** [[https://github.com/alphapapa/org-make-toc][Org make toc]]
:PROPERTIES:
:CUSTOM_ID: org-make-toc
:END:

Helper to create table of contents in org files.

#+begin_src emacs-lisp
  (use-package org-make-toc
    :commands org-make-toc
    :custom
    (org-make-toc-insert-custom-ids t)
    :config
    (message "`org-make-toc' loaded"))
#+end_src

** [[https://gitlab.com/Titan-C/org-cv][Org CV]]
:PROPERTIES:
:CUSTOM_ID: org-cv
:END:

#+begin_src emacs-lisp
  (use-package ox-awesomecv
    :load-path "lisp/org-cv/"
    :ensure nil
    :init (advice-add #'org-export-to-file
                      :before (lambda (&rest _) (require 'ox-awesomecv)))
    :config (message "`ox-awesomecv' loaded"))

  (use-package ox-moderncv
    :load-path "lisp/org-cv/"
    :ensure nil
    :init (advice-add #'org-export-to-file
                      :before (lambda (&rest _) (require 'ox-awesomecv)))
    :config (message "`ox-moderncv' loaded"))
#+end_src

* Collaborative editing
:PROPERTIES:
:CUSTOM_ID: collaborative-editing
:END:

#+begin_src emacs-lisp
  (use-package crdt
    :commands (crdt-share-buffer crdt-connect)
    :custom
    (crdt-use-tuntox 'confirm)
    (crdt-tuntox-password-in-url t))
#+end_src

* [[https://github.com/emacs-lsp/lsp-mode/][LSP]]
:PROPERTIES:
:CUSTOM_ID: lsp
:END:

Minor mode acting as a client between a language server protocol and Emacs.

** Main mode
:PROPERTIES:
:CUSTOM_ID: main-mode-1
:END:

#+begin_src emacs-lisp
  ;; Taken from doomemacs

  (defvar pokemacs-lsp--default-read-process-output-max nil)
  (defvar pokemacs-lsp--default-gcmh-high-cons-threshold nil)
  (defvar pokemacs-lsp--optimization-init-p nil)

  (define-minor-mode pokemacs-lsp-optimization-mode
    "Deploys universal GC and IPC optimizations for `lsp-mode' and `eglot'."
    :global t
    :init-value nil
    (if (not pokemacs-lsp-optimization-mode)
        (setq-default read-process-output-max pokemacs-lsp--default-read-process-output-max
                      gcmh-high-cons-threshold pokemacs-lsp--default-gcmh-high-cons-threshold
                      pokemacs-lsp--optimization-init-p nil)
      ;; Only apply these settings once!
      (unless pokemacs-lsp--optimization-init-p
        (setq pokemacs-lsp--default-read-process-output-max (default-value 'read-process-output-max)
              pokemacs-lsp--default-gcmh-high-cons-threshold (default-value 'gcmh-high-cons-threshold))
        (setq-default read-process-output-max (* 1024 1024))
        ;; REVIEW LSP causes a lot of allocations, with or without the native JSON
        ;;        library, so we up the GC threshold to stave off GC-induced
        ;;        slowdowns/freezes. Doom uses `gcmh' to enforce its GC strategy,
        ;;        so we modify its variables rather than `gc-cons-threshold'
        ;;        directly.
        (setq-default gcmh-high-cons-threshold (* 2 pokemacs-lsp--default-gcmh-high-cons-threshold))
        (gcmh-set-high-threshold)
        (setq pokemacs-lsp--optimization-init-p t))))

  (use-package lsp-mode
    ;; :ensure (:repo "~/lsp-mode")
    :init
    (defun pokemacs--set-completion-capf ()
      (if pokemacs-complete-keywords
          (setq-local completion-at-point-functions
                      (list (cape-capf-super #'lsp-completion-at-point #'cape-keyword)))
        (setq-local completion-at-point-functions
                    (list #'lsp-completion-at-point))))

    (defun pokemacs-toggle-completion-capf ()
      (interactive)
      (setq pokemacs-complete-keywords (not pokemacs-complete-keywords))
      (pokemacs--set-completion-capf))

    (defun minad/lsp-mode-setup-completion ()
      (setf (alist-get 'styles (alist-get 'lsp-capf completion-category-defaults))
            '(hotfuzz))
      (pokemacs--set-completion-capf))

    (defconst pokemacs-lsp-mode-breadcrumb-segments
      (if use-header-line
          '(project file)
        '(project path-up-to-project file symbols)))

    (defun pokemacs-define-correct-key ()
      (general-define-key
       :keymaps 'pokemacs-flycheck-overlay-map
       "M-$" '("LSP code action" . lsp-execute-code-action)))

    :hook ((lsp-mode . pokemacs-lsp-optimization-mode)
           (lsp-mode . pokemacs-define-correct-key)
           (lsp-completion-mode . minad/lsp-mode-setup-completion)
           (caml-mode . lsp-deferred)
           (cc-mode . lsp-deferred)
           (clojure-mode . lsp-deferred)
           (conf-toml-mode . lsp-deferred)
           (clojurescript-mode-hook . lsp-deferred)
           (clojurec-mode-hook . lsp-deferred)
           (elm-mode . lsp-deferred)
           (elixir-mode . lsp-deferred)
           (enh-ruby-mode . lsp-deferred)
           (fsharp-mode . lsp-deferred)
           (js-mode . lsp-deferred)
           (js-ts-mode . lsp-deferred)
           (kotlin-mode . lsp-deferred)
           (rustic-mode . lsp-deferred)
           (typescript-ts-mode . lsp-deferred)
           (tuareg-mode . lsp-deferred)
           (zig-mode    . lsp-deferred)
           (zig-ts-mode    . lsp-deferred))

    :general
    (:keymaps 'lsp-mode-map
              "C-c C-t" 'lsp-describe-thing-at-point
              "C-c C-l" 'lsp-find-definition
              "C-c C-j" 'lsp-find-type-definition
              "C-c &"   'pop-global-mark :keymaps 'override)
    (:keymaps 'lsp-command-map
              "d"   'lsp-find-definition
              "r"   'lsp-find-references
              "n"   'lsp-ui-find-next-reference
              "p"   'lsp-ui-find-prev-reference
              "i"   'counsel-semantic-or-imenu
              "R"   'lsp-rename
              "f"   'consult-flycheck
              "t r" 'lsp-treemacs-references
              "t s" 'lsp-treemacs-symbols)

    :custom
    (lsp-log-io nil)
    (lsp-completion-default-behaviour :insert)
    (lsp-headerline-breadcrumb-enable t)
    (lsp-headerline-breadcrumb-segments pokemacs-lsp-mode-breadcrumb-segments)
    (lsp-headerline-breadcrumb-enable-symbol-numbers nil)
    (lsp-modeline-code-actions-enable nil)
    (lsp-keymap-prefix "M-l")
    (lsp-prefer-capf t)
    (lsp-lens-enable nil)
    (lsp-completion-provider :none)
    (lsp-completion-enable t)
    (lsp-enable-imenu nil)
    (lsp-enable-snippet nil)
    (lsp-enable-dap-auto-configure nil)
    (lsp-disabled-clients '((python-mode . pyls) (python-ts-mode . pyls)))
    ;; Rust-analyzer is the almost official lsp server for Rust
    (lsp-rust-server 'rust-analyzer)
    (lsp-rust-analyzer-cargo-watch-command "clippy")
    ;; enable / disable the hints as you prefer:
    (lsp-rust-analyzer-server-display-inlay-hints t)
    (lsp-rust-analyzer-display-lifetime-elision-hints-enable "skip_trivial")
    (lsp-rust-analyzer-display-chaining-hints t)
    (lsp-rust-analyzer-display-lifetime-elision-hints-use-parameter-names nil)
    (lsp-rust-analyzer-display-closure-return-type-hints t)
    (lsp-rust-analyzer-display-parameter-hints nil)
    (lsp-rust-analyzer-display-reborrow-hints nil)
    (lsp-ui-peek-find-references nil (list :folders (vector (projectile-project-root))))

    :config
    (advice-add 'lsp-completion-at-point :around #'cape-wrap-buster)
    (which-key-add-keymap-based-replacements lsp-command-map "u" "UI")
    (lsp-enable-which-key-integration t)

    (lsp-register-client
     (make-lsp-client
      :new-connection (lsp-stdio-connection
                       '("opam" "exec" "--" "ocamllsp"))
      :major-modes '(caml-mode tuareg-mode)
      :server-id 'ocaml-lsp-server))

    (message "`lsp' loaded"))
#+end_src

** [[https://github.com/emacs-lsp/lsp-ui][Lsp ui]]
:PROPERTIES:
:CUSTOM_ID: lsp-ui
:END:

#+begin_src emacs-lisp
  ;; Useful link : https://emacs-lsp.github.io/lsp-mode/tutorials/how-to-turn-off/
  (use-package lsp-ui
    :hook (lsp-mode . lsp-ui-mode)
    :general
    ("C-M-i" 'lsp-ui-doc-show)
    ("C-c i" 'lsp-ui-imenu)
    (:keymaps 'lsp-ui-mode-map
              [remap xref-find-definitions] 'lsp-ui-peek-find-definitions
              [remap xref-find-references] 'lsp-ui-peek-find-references
              )
    (:keymaps 'lsp-ui-doc-mode-map
              "M-f" 'lsp-ui-doc-focus-frame)
    (:keymaps 'lsp-ui-doc-frame-mode-map
              "q" (lambda () (interactive) (lsp-ui-doc--delete-frame)))
    (:keymaps 'lsp-command-map
              "u f" 'lsp-ui-doc-focus-frame
              "u i" 'lsp-ui-imenu)
    :custom
    (lsp-ui-doc-delay 0.9)
    (lsp-ui-doc-position 'at-point)
    ;; Whether or not to enable the header which displays the symbol string.
    (lsp-ui-doc-header t)
    ;; Whether or not to include the object signature/type in the frame.
    (lsp-ui-doc-include-signature t)
    (lsp-ui-doc-show-with-cursor nil)
    (lsp-ui-doc-show-with-mouse nil)
    ;; Border color of the frame
    (lsp-ui-doc-border (face-foreground 'default))
    ;; Whether or not to enable lsp-ui-sideline
    (lsp-ui-sideline-enable nil)
    (lsp-ui-doc-use-webkit t)
    (lsp-ui-doc-use-childframe t)
    ;; Ignore duplicates when there is a same symbol with same contents
    ;; (lsp-ui-sideline-ignore-duplicate t)
    ;; Whether to show code actions in sideline.
    ;; (lsp-ui-sideline-show-code-actions nil)
    :config (message "`lsp-ui' loaded"))
#+end_src

** [[https://github.com/emacs-lsp/lsp-treemacs][Lsp treemacs]]
:PROPERTIES:
:CUSTOM_ID: lsp-treemacs
:END:

#+begin_src emacs-lisp
  (use-package lsp-treemacs
    :after lsp
    :config (message "`lsp-treemacs' loaded"))
#+end_src

** TODO [[https://github.com/gagbo/consult-lsp][Consult lsp]]
:PROPERTIES:
:CUSTOM_ID: consult-lsp
:END:

TODO: Not working with OCaml

#+begin_src emacs-lisp
  (use-package consult-lsp
    :disabled)
#+end_src


* Prog mode utilities
:PROPERTIES:
:CUSTOM_ID: prog-mode-utilities
:END:

** Prog-mode
:PROPERTIES:
:CUSTOM_ID: prog-mode
:END:

#+begin_src emacs-lisp
  (use-package prog-mode
    :ensure nil
    :hook
    (prog-mode . pokemacs-clear-compilation-finish-functions)
    :init
    (defun pokemacs-clear-compilation-finish-functions ()
      (setq compilation-finish-functions nil))
    (defun pokemacs--compilation-goto-locus-no-split (orig-fun &rest args)
      "Prevent window splitting when clicking on compilation errors."
      (let ((display-buffer-overriding-action
             '((display-buffer-reuse-window
                display-buffer-in-previous-window
                display-buffer-use-some-window))))
        (apply orig-fun args)))
    (defun pokemacs--loop-error (orig-fun &rest args)
      (condition-case error (apply orig-fun args)
        (user-error
         (message "%s" (car (cdr error)))
         (let ((args (cl-destructuring-bind (arg . reset) args
                       (cond
                        ;; arg is nil or > 0 meaning we're going to the next-error
                        ((or (null arg) (> arg 0))
                         (list arg t))

                        (t
                         (with-current-buffer compilation-last-buffer
                           (setq compilation-current-error (point-max)))
                         (list arg nil))))))
           (apply orig-fun args)))))
    :config
    ;; Prevent emacs from splitting a window when clicking on an error
    (advice-add 'compilation-goto-locus :around #'pokemacs--compilation-goto-locus-no-split)
    (advice-add 'next-error :around #'pokemacs--loop-error))
#+end_src

** [[https://github.com/radian-software/apheleia][Apheleia]]
:PROPERTIES:
:CUSTOM_ID: apheleia
:END:

Asynchronous code formatting after saving files.

#+begin_src emacs-lisp
  (use-package apheleia
    :init (apheleia-global-mode +1)
    :config
    (let*
        ((shfmt-value (alist-get 'shfmt apheleia-formatters))
         (command (pop shfmt-value))
         (shfmt-value (cons command (cons "-sr" shfmt-value))))
      (setf (alist-get 'shfmt apheleia-formatters) shfmt-value))
    (setf (alist-get 'isort apheleia-formatters)
          '("isort" "--stdout" "-"))
    (setf (alist-get 'python-mode apheleia-mode-alist)
          '(isort black))
    (setf (alist-get 'python-ts-mode apheleia-mode-alist)
          '(isort black))
    (push '(enh-ruby-mode . rubocop) apheleia-mode-alist)
    (message "`apheleia' loaded"))
#+end_src

** [[https://github.com/emacs-lsp/dap-mode][DAP]]
:PROPERTIES:
:CUSTOM_ID: dap
:END:

*** Main mode
:PROPERTIES:
:CUSTOM_ID: main-mode-2
:END:
Debug Adapter Protocol client for emacs. Need to play a bit with it to know how to use it.

#+begin_src emacs-lisp
  (use-package dap-mode
    :general
    (:keymaps 'lsp-mode-map
              "M-<f5>" 'dap-hydra)
    :hook ((dap-mode . dap-ui-mode)
           (dap-session-created . (lambda (&_rest) (dap-hydra)))
           (dap-terminated . (lambda (&_rest) (dap-hydra/nil))))

    :custom
    (dap-auto-configure-features '(sessions locals controls tooltip))

    :config
    (message "`dap' loaded"))
#+end_src

** [[https://github.com/jacktasia/dumb-jump][Dumb jump]]
:PROPERTIES:
:CUSTOM_ID: dumb-jump
:END:

#+begin_src emacs-lisp
  (use-package dumb-jump
    :config
    (add-hook 'xref-backend-functions #'dumb-jump-xref-activate)
    (defhydra dumb-jump-hydra (:color blue :columns 3)
      "Dumb Jump"
      ("j" dumb-jump-go "Go")
      ("o" dumb-jump-go-other-window "Other window")
      ("e" dumb-jump-go-prefer-external "Go external")
      ("x" dumb-jump-go-prefer-external-other-window "Go external other window")
      ("i" dumb-jump-go-prompt "Prompt")
      ("l" dumb-jump-quick-look "Quick look")
      ("b" dumb-jump-back "Back"))
    (message "`dumb-jump' loaded"))
#+end_src

** Find-sibling
:PROPERTIES:
:CUSTOM_ID: find-sibling
:END:

#+begin_src emacs-lisp
  (setq find-sibling-rules
        '(
          ("\\([^/]+\\)\\.org\\'" "\\1.el")
          ("\\([^/]+\\)\\.el\\'" "\\1.org")
          ("\\([^/]+\\)\\.c\\'" "\\1.h")
          ("\\([^/]+\\)\\.h\\'" "\\1.c")))

  (defcustom create-sibling-rules nil
    "Rules for creating \"sibling\" files.
  this is used by the `pokemacs-find-sibling-file-wrapper' command.

  See `find-sibling-rules' for more informations.

  Unlike `find-sibling-rules', `create-sibling-rules' should only
  have one rule for each file type."
    :group 'pokemacs-languages
    :type 'sexp
    :version "29.1"
    :tag " Create sibling rules")

  (setq create-sibling-rules
        '(("\\([^/]+\\)\\.ml\\'" . ("\\1.mli" . lsp-ocaml-infer-interface))))

  (defun pokemacs-find-sibling-file (file)
    "Visit a \"sibling\" file of FILE.
     When called interactively, FILE is the currently visited file.

     The \"sibling\" file is defined by the `find-sibling-rules' variable."
    (interactive
     (progn
       (unless buffer-file-name
         (user-error "Not visiting a file"))
       (list buffer-file-name)))
    (condition-case
        nil
        (find-sibling-file file)
      (user-error
       (-let* (((expansion . command)
                (alist-get file create-sibling-rules nil nil 'string-match))
               (match-data (match-data))
               (start 0))
         (cond
          ((null expansion)
           (user-error "Couldn't find any sibling files nor a way to create a sibling"))

          (t
           ;; Expand \\1 forms in the expansions.
           (while (string-match "\\\\\\([&0-9]+\\)" expansion start)
             (let ((index (string-to-number (match-string 1 expansion))))
               (setq start (match-end 0)
                     expansion
                     (replace-match
                      (substring file
                                 (elt match-data (* index 2))
                                 (elt match-data (1+ (* index 2))))
                      t t expansion))
               (let* ((file (file-relative-name file (projectile-project-root)))
                      (output-buffer (get-buffer-create "*temp*" t))
                      (new-file (expand-file-name expansion))
                      (display-buffer-alist
                       (list
                        (cons "\\*temp\\*.*"
                              (cons #'display-buffer-no-window nil)))))
                 (when
                     (y-or-n-p (format-message "Create `%s'?" new-file))
                   (cond
                    ((functionp command)
                     ;; If the command is a function we apply it in the current buffer
                     (funcall command))
                    ((stringp command)
                     ;; If the command is a string, call it as a shell command
                     (with-current-buffer output-buffer
                       (projectile-run-shell-command-in-root
                        (concat command " " file) output-buffer)
                       (dired-create-empty-file new-file)
                       (write-file new-file))))
                   (kill-buffer output-buffer)
                   (find-file new-file)))))))))))

  (general-define-key
   [remap find-sibling-file]    'pokemacs-find-sibling-file
   "C-c C-a"                    'pokemacs-find-sibling-file)
#+end_src

** [[https://github.com/Fuco1/fontify-face][Fontify face]]
:PROPERTIES:
:CUSTOM_ID: fontify-face
:END:

Allows to see immediately how a face will look

#+begin_src emacs-lisp
  (use-package fontify-face
    :hook (font-lock-mode . fontify-face-mode)
    :config (message "`fontify-face' loaded"))
#+end_src

** [[https://github.com/flycheck/flycheck][Flycheck]]
:PROPERTIES:
:CUSTOM_ID: flycheck
:END:

On the fly syntax checking. One of the greatest package there is for making programming easier.

*** Main mode
:PROPERTIES:
:CUSTOM_ID: main-mode-3
:END:

#+begin_src emacs-lisp
  (use-package flycheck
    :init
    (define-prefix-command 'pokemacs-fly-map nil "Fly-")
    (defvar-keymap pokemacs-flycheck-overlay-map
      :doc "Keymap attached to lsp and flycheck overlays.")
    (fset 'pokemacs-flycheck-overlay-map pokemacs-flycheck-overlay-map)
    :hook ((prog-mode markdown-mode git-commit-mode text-mode) . flycheck-mode)
    :general
    (:keymaps 'pokemacs-fly-map
              "p" 'flycheck-prev-error)
    :custom
    (flycheck-indication-mode 'left-fringe)
    :config
    (pretty-hydra-define
      hydra-flycheck
      ( :title "Flycheck"
        :pre (flycheck-list-errors)
        :post (quit-windows-on "*Flycheck errors*")
        :hint nil
        :quit-key "q")
      (
       "Errors"
       (("f" flycheck-error-list-set-filter "Filter"))

       "Navigation"
       (("j" flycheck-next-error "Next")
        ("k" flycheck-previous-error "Previous")
        ("gg" flycheck-first-error "First")
        ("G" (progn (goto-char (point-max)) (flycheck-previous-error)) "Last"))))
    ;; (advice-add 'flycheck-next-error :filter-args #'flycheck-reset)

    (defun pokemacs-show-which-key-flycheck-overlay (&rest args)
      ;; Delay of 0.1 seconds before executing
      (run-with-idle-timer
       pokemacs-which-key-idle-delay nil
       (lambda ()
         (let ((which-key-use-C-h-commands nil)
               (which-key-paging-key "C-<f5>"))
           (which-key-show-keymap 'pokemacs-flycheck-overlay-map t)))))

    (defun flycheck-reset (&optional n reset)
      (if (flycheck-next-error-pos n reset)
          (list n reset)
        (list n t)))
    (let ((overlays `(flycheck-info-overlay
                      flycheck-error-overlay
                      flycheck-warning-overlay
                      lsp-flycheck-warning-unnecessary-category)))
      (dolist (overlay overlays)
        (put overlay 'keymap pokemacs-flycheck-overlay-map)
        (put overlay 'cursor-sensor-functions '(pokemacs-show-which-key-flycheck-overlay))))
    (cursor-sensor-mode 1)
    (message "`flycheck' loaded"))
#+end_src

*** Flycheck Correct
:PROPERTIES:
:CUSTOM_ID: flycheck-correct
:END:

#+begin_src emacs-lisp
  (use-package flycheck-correct
    :load-path "lisp/"
    :ensure nil
    :hook flycheck-mode
    :general
    (:keymaps 'flycheck-mode-map
              "M-RET" 'pokemacs-correct-or-newline)
    :config (message "`flycheck-correct' loaded"))
#+end_src

*** [[https://github.com/cpitclaudel/quick-peek][Quick Peek]]
:PROPERTIES:
:CUSTOM_ID: quick-peek
:END:

#+begin_src emacs-lisp
  (if (display-graphic-p)
      (use-package quick-peek
        :config (message "`quick-peek' loaded")))
#+end_src

*** [[https://github.com/flycheck/flycheck-inline][Flycheck inline]]
:PROPERTIES:
:CUSTOM_ID: flycheck-inline
:END:

#+begin_src emacs-lisp
  (when (and use-inline-errors (display-graphic-p))
    (use-package flycheck-inline
      :hook (flycheck-mode . flycheck-inline-mode)
      :config
      (setq flycheck-inline-display-function
            (lambda (msg pos err)
              (let* ((ov (quick-peek-overlay-ensure-at pos))
                     (contents (quick-peek-overlay-contents ov)))
                (setf (quick-peek-overlay-contents ov)
                      (concat contents (when contents "\n") msg))
                (quick-peek-update ov)))
            flycheck-inline-clear-function #'quick-peek-hide))
    (message "`flycheck-inline' loaded"))
#+end_src

*** [[https://github.com/minad/consult-flycheck][Consult flycheck]]
:PROPERTIES:
:CUSTOM_ID: consult-flycheck
:END:

#+begin_src emacs-lisp
  (use-package consult-flycheck
    :general
    ("C-c l" 'consult-flycheck)
    :config (message "`consult-flycheck' loaded"))
#+end_src

*** [[https://github.com/flycheck/flycheck-rust][Flycheck Rust]]
:PROPERTIES:
:CUSTOM_ID: flycheck-rust
:END:

#+begin_src emacs-lisp
  (use-package flycheck-rust
    :hook (flycheck-mode . (lambda () (flycheck-rust-setup))))
#+end_src

** [[https://www.emacswiki.org/emacs/HideShow][Hideshow]]
:PROPERTIES:
:CUSTOM_ID: hideshow
:END:

#+begin_src emacs-lisp
  (use-package hideshow
    :ensure nil
    :commands (hs-minor-mode
               hs-toggle-hiding)
    :diminish hs-minor-mode
    :custom
    (hs-isearch-open t)
    :config
    (message "`hideshow' loaded"))
#+end_src

** [[https://github.com/bbatsov/projectile][Projectile]]
:PROPERTIES:
:CUSTOM_ID: projectile
:END:

Project interaction library.

#+begin_src emacs-lisp
  (use-package projectile
    :demand t
    :hook (prog-mode . projectile-mode)
    :general
    ("M-p"  'projectile-command-map)
    ("<f5>" 'projectile-compile-project)
    ("<f6>" 'pokemacs-recompile)
    :config
    (defun pokemacs-recompile ()
      "Run project configure command.

  Normally you'll be prompted for a compilation command, unless
  variable `compilation-read-command'.  You can force the prompt
  with a prefix ARG."
      (interactive)
      (let ((command (projectile-compilation-command (projectile-compilation-dir)))
            (command-map (if (projectile--cache-project-commands-p) projectile-compilation-cmd-map))
            (compilation-read-command nil))
        (projectile--run-project-cmd command command-map
                                     :show-prompt nil
                                     :prompt-prefix nil
                                     :save-buffers t
                                     :use-comint-mode projectile-configure-use-comint-mode)))
    (message "`projectile' loaded"))
#+end_src

** [[https://github.com/twlz0ne/separedit.el][Separedit]]
:PROPERTIES:
:CUSTOM_ID: separedit
:END:

Allows to edit comments in a separate buffer with a chosen text-mode (default is markdown-mode). When inside a comment, hit ~C-c C-e~ to start editing it in its own buffer.

#+begin_src emacs-lisp
  (use-package separedit
    :general
    ("C-c C-e"                 'separedit)
    :custom
    (separedit-default-mode 'markdown-mode)
    :config
    (message "`separedit' loaded"))
#+end_src

** [[https://github.com/Alexander-Miller/treemacs][Treemacs]]
:PROPERTIES:
:CUSTOM_ID: treemacs
:END:

#+begin_src emacs-lisp
  (use-package treemacs
    :config (message "`treemacs' loaded"))
#+end_src

* Windows/Frame management
:PROPERTIES:
:CUSTOM_ID: windowsframe-management
:END:

** DISABLED Uniquify
:PROPERTIES:
:CUSTOM_ID: disabled-uniquify
:END:

#+begin_src emacs-lisp
  (use-package uniquify
    :disabled
    :custom
    (uniquify-buffer-name-style 'reverse)
    (uniquify-separator " • ")
    (uniquify-after-kill-buffer-p t)
    (uniquify-ignore-buffers-re "^\\*")
    :config
    (message "`uniquify' loaded"))
#+end_src

** [[https://www.emacswiki.org/emacs/WinnerMode][Winner]]
:PROPERTIES:
:CUSTOM_ID: winner
:END:

Allows to undo and redo changes in window configurations

#+begin_src emacs-lisp
  (use-package winner
    :demand t
    :ensure nil
    :custom
    (winner-boring-buffers
     '("*Completions*"
       "*Compile-Log*"
       "*inferior-lisp*"
       "*Fuzzy Completions*"
       "*Apropos*"
       "*Help*"
       "*cvs*"
       "*Buffer List*"
       "*Ibuffer*"
       "*esh command on file*"))
    :config
    (winner-mode 1)
    (message "`winner' loaded"))
#+end_src

** [[https://github.com/abo-abo/ace-window][Ace window]]
:PROPERTIES:
:CUSTOM_ID: ace-window
:END:

~C-x C-o~ for better window switching.

#+begin_src emacs-lisp
  (use-package ace-window
    :demand t
    :custom
    (aw-dispatch-always t)
    :config
    (pretty-hydra-define
      hydra-window (:title "Window management" :quit-key "q")
      ("Movement"
       (("<left>" windmove-left "←")
        ("<down>" windmove-down "↓")
        ("<up>" windmove-up "↑")
        ("<right>" windmove-right "→"))

       "Split"
       (("v" (lambda ()
               (interactive)
               (split-window-right)
               (windmove-right)) "Vertical")
        ("h" (lambda ()
               (interactive)
               (split-window-below)
               (windmove-down)) "Horizontal")
        ("u" (progn
               (winner-undo)
               (setq this-command 'winner-undo)) "Undo")
        ("r" winner-redo "Redo"))

       "Switch"
       (("f" find-file "Find file")
        ("a" (lambda ()
               (interactive)
               (ace-window 1)
               (add-hook 'ace-window-end-once-hook
                         'hydra-window/body)) "Ace window")
        ("s" (lambda ()
               (interactive)
               (ace-swap-window)
               (add-hook 'ace-window-end-once-hook
                         'hydra-window/body)) "Swap"))

       "Resize"
       (("C-<left>" (lambda () (interactive) (pokemacs-resize-window t -5)) "X←")
        ("C-<right>" (lambda () (interactive) (pokemacs-resize-window t 5)) "X→")
        ("C-<up>" (lambda () (interactive) (pokemacs-resize-window nil 5)) "X↑")
        ("C-<down>" (lambda () (interactive) (pokemacs-resize-window nil -5)) "X↓"))

       "Purpose"
       (("M" delete-other-windows "Delete other")
        ("d" delete-window "Delete")
        ("P" purpose-set-window-purpose "Set purpose")
        ("!" purpose-toggle-window-purpose-dedicated "Toggle purpose")
        ("#" purpose-toggle-window-buffer-dedicated "Toggle buffer"))))
    (set-face-attribute 'aw-leading-char-face nil :height 2.5)
    (message "`ace-window' loaded"))
#+end_src

** [[https://codeberg.org/joostkremers/visual-fill-column][Visual fill column]]
:PROPERTIES:
:CUSTOM_ID: visual-fill-column
:END:

This mode will center the text when only one window is displayed.

#+begin_src emacs-lisp
  (when use-visual-fill
    (use-package visual-fill-column
      :hook
      (window-state-change . pokemacs-visual-fill-one-window)
      ((prog-mode org-mode text-mode) . visual-fill-column-mode)

      :init (defvar pokemacs-visual-fill-enabled t)

      :custom
      (visual-fill-column-width 100)
      (visual-fill-column-center-text nil)

      :config
      (defun pokemacs-toggle-visual-fill ()
        (interactive)
        (visual-fill-column-mode 'toggle)
        (setq pokemacs-visual-fill-enabled (not pokemacs-visual-fill-enabled))
        (setq global-visual-fill-column-mode pokemacs-visual-fill-enabled)
        (setq visual-fill-column-center-text pokemacs-visual-fill-enabled))

      (defun pokemacs-visual-fill-one-window ()
        (when pokemacs-visual-fill-enabled
          (if (and (window-full-width-p) pokemacs-visual-fill-enabled)
              (progn
                (setq visual-fill-column-center-text t)
                (global-visual-fill-column-mode 1)
                (setq mode-line-right-align-edge 'window)
                (set-window-fringes (selected-window) 8 8 nil nil))
            (global-visual-fill-column-mode -1))))

      (message "`visual-fill-column' loaded")))
#+end_src

** Pokemacs layout
:PROPERTIES:
:CUSTOM_ID: pokemacs-layout
:END:

#+begin_src emacs-lisp
  (use-package pokemacs-layout
    :ensure (:type git :repo "https://codeberg.org/mattiasdrp/pokemacs-layout.git")
    ;; :ensure nil
    ;; :load-path "~/pokemacs-layout"
    :commands pokemacs-layout-apply pokemacs-layout-monitor-names
    pokemacs-restore-session pokemacs-layout-current-monitor
    :config
    (defun pokemacs-restore-session (&optional columns)
      "Restore a session by creating the proper buffers."
      (interactive "P")
      (let ((pokemacs-layout-columns (or columns pokemacs-layout-columns)))
        (setq current-prefix-arg nil)
        (pokemacs-layout--apply "Prog custom layout"))))
#+end_src

** Window Purpose
:PROPERTIES:
:CUSTOM_ID: window-purpose
:END:

#+begin_src emacs-lisp
  (when use-window-purpose
    (use-package window-purpose
      :config
      (purpose-mode)
      (purpose-x-magit-multi-on)
      (message "`window-purpose' loaded")))
#+end_src

* Completion
:PROPERTIES:
:CUSTOM_ID: completion
:END:

By completion two things are intended:
- text completion (be it for programs or simple text, see [[#lsp][LSP]])
- minibuffer and command completions (emacs related, see [[#vertico][Vertico]] and friends below)

** [[https://kristofferbalintona.me/posts/202202211546/][Vertico]]
:PROPERTIES:
:CUSTOM_ID: vertico
:END:

Vertico works with the default completion system instead of reimplementing a whole system allowing better flexibility and package binding.

*** [[https://github.com/minad/vertico][Main mode]]
:PROPERTIES:
:CUSTOM_ID: main-mode-4
:END:

#+begin_src emacs-lisp
  (use-package vertico
    :ensure (vertico :files (:defaults "extensions/*"))
    :after general
    :init (vertico-mode)
    :general
    (:keymaps 'vertico-map
              "<tab>" #'minibuffer-complete         ; common prefix
              "<escape>" #'minibuffer-keyboard-quit ; Close minibuffer
              "C-M-n" #'vertico-next-group
              "C-M-p" #'vertico-previous-group
              "?" #'minibuffer-completion-help
              "M-RET" #'embark-dwim ;; pick some comfortable binding
              ;; "C-<up>" #'other-window
              )
    (:keymaps 'minibuffer-local-map
              "M-h" #'backward-kill-word)
    :custom
    ;; Optionally enable cycling for `vertico-next' and `vertico-previous'.
    (vertico-cycle t)
    :config
    ;; (setq vertico-sort-function 'vertico-sort-alpha)
    ;; Use `consult-completion-in-region' if Vertico is enabled.
    ;; Otherwise use the default `completion--in-region' function.
    (setq completion-in-region-function
          (lambda (&rest args)
            (apply (if vertico-mode
                       #'consult-completion-in-region
                     #'completion--in-region)
                   args)))
    ;; Prefix the current candidate with “» ”. From
    ;; https://github.com/minad/vertico/wiki#prefix-current-candidate-with-arrow
    (advice-add #'vertico--format-candidate :around
                (lambda (orig cand prefix suffix index _start)
                  (setq cand (funcall orig cand prefix suffix index _start))
                  (concat
                   (if (= vertico--index index)
                       (propertize "⮕ " 'face 'vertico-current)
                     "  ")
                   cand)))
    (message "`vertico' loaded"))
#+end_src

*** Vertico directory
:PROPERTIES:
:CUSTOM_ID: vertico-directory
:END:

Better typing of file/directory paths

Useful keybindings are:
- ~DEL~ will delete the whole subdirectory or only a character if on a filename
- ~M-DEL~ will delete the whole subdirectory or a word if on a filename

#+begin_src emacs-lisp
  (use-package vertico-directory
    :after vertico
    :ensure nil
    :hook (rfn-eshadow-update-overlay . vertico-directory-tidy)
    ;; More convenient directory navigation commands
    :general
    (:keymaps 'vertico-map
              "RET" 'vertico-directory-enter
              "<DEL>" 'vertico-directory-delete-char
              "M-<DEL>" 'vertico-directory-delete-word)
    ;; Tidy shadowed file names
    :config (message "`vertico-directory' loaded"))
 #+end_src


*** Vertico-prescient
:PROPERTIES:
:CUSTOM_ID: vertico-prescient
:END:

#+begin_src emacs-lisp
  (use-package vertico-prescient
    :demand t
    :after vertico prescient
    :custom
    ;; Sorting
    (vertico-prescient-enable-sorting t)
    (vertico-prescient-override-sorting nil) ; Don't override `display-sort-function'
    ;; Filtering
    (vertico-prescient-enable-filtering nil) ; We want orderless to do the filtering
    :config
    (vertico-prescient-mode 1)
    (message "`vertico-prescient' loaded"))
#+end_src

*** TODO Vertico multiform
:PROPERTIES:
:CUSTOM_ID: vertico-multiform
:END:

This extension allows to choose the way each minibuffer will be displayed.

TODO: Test all the possible minibuffers and customize them as I'd like them to be

#+begin_src emacs-lisp
  (use-package vertico-multiform
    :after vertico
    :hook (vertico-mode . vertico-multiform-mode)
    :ensure nil
    :custom
    (vertico-buffer-display-action '(display-buffer-in-side-window
                                     (side . right)
                                     (window-width . 0.3)))
    :config
    ;; Sort directories before files
    (defun sort-characters (characters)
      (sort characters (lambda (name1 name2) (< (char-from-name name1) (char-from-name name2)))))

    ;; Sort directories before files
    (defun sort-directories-first (files)
      (nconc (vertico-sort-alpha (seq-remove (lambda (x) (string-suffix-p "/" x)) files))
             (vertico-sort-alpha (seq-filter (lambda (x) (string-suffix-p "/" x)) files))))

    (when use-posframe
      (mapcar (lambda (properties)
                (setcdr properties (push 'posframe (cdr properties))))
              vertico-multiform-commands)
      (mapcar (lambda (properties) (setcdr properties (push 'posframe (cdr properties))))
              vertico-multiform-categories)
      (pokemacs-appendq! vertico-multiform-categories
                         '((t posframe)))
      (pokemacs-appendq! vertico-multiform-commands
                         '((posframe
                            (vertico-posframe-poshandler . posframe-poshandler-frame-top-center)
                            (vertico-posframe-border-width . 10))
                           (t posframe))))

    (vertico-multiform-mode)
    (message "`vertico-multiform' loaded"))

  (when use-posframe
    (use-package vertico-posframe
      :after vertico
      :custom
      (vertico-posframe-width 80)
      :config
      (vertico-posframe-mode 1)
      (message "`vertico-posframe' loaded")))
#+end_src

** [[https://github.com/minad/consult/][Consult]]
:PROPERTIES:
:CUSTOM_ID: consult
:END:

#+begin_src emacs-lisp
  (use-package consult
    :ensure nil
    ;; Enable automatic preview at point in the *Completions* buffer. This is
    ;; relevant when you use the default completion UI.
    :hook (completion-list-mode . consult-preview-at-point-mode)
    :ensure-system-package (rg . ripgrep)
    ;; Replace bindings. Lazily loaded due by `use-package'.
    :general
    ;; C-c bindings (mode-specific-map)
    ("C-c h" 'consult-history)
    ("C-c m" 'consult-mode-command)
    ("C-c k" 'consult-kmacro)
    ;; C-x bindings (ctl-x-map)
    ([remap repeat-complex-command] 'consult-complex-command)
    ([remap switch-to-buffer] 'consult-buffer)
    ([remap switch-to-buffer-other-window] 'consult-buffer-other-window)
    ([remap switch-to-buffer-other-frame] 'consult-buffer-other-frame)
    ([remap bookmark-jump] 'consult-bookmark)
    ([remap project-switch-to-buffer] 'consult-project-buffer)
    ([remap yank-pop] 'consult-yank-replace)
    ([remap apropos-command] 'consult-apropos)
    ([remap goto-line] 'consult-goto-line)
    ;; ([remap isearch-forward] 'consult-line)
    ;; Custom M-# bindings for fast register access
    ("M-#" 'consult-register-load)
    ("M-'" 'consult-register-store)          ;; orig. abbrev-prefix-mark (unrelated)
    ("C-M-#" 'consult-register)
    ;; Other custom bindings
    ("<help> a" 'consult-apropos)            ;; orig. apropos-command
    ;; M-g bindings (goto-map)
    ("M-g e" 'consult-compile-error)
    ("M-g o" 'consult-outline)               ;; Alternative: consult-org-heading
    ("M-g m" 'consult-mark)
    ("M-g k" 'consult-global-mark)
    ("M-g i" 'consult-imenu)
    ("M-g I" 'consult-imenu-multi)
    ;; M-s bindings (search-map)
    ("M-s d" 'consult-find)
    ("M-s D" 'consult-locate)
    ("M-s g" 'consult-grep)
    ("M-s G" 'pokemacs-consult-git-grep-always-prompt-dir)
    ("M-s r" 'consult-ripgrep)
    ("M-s R" 'pokemacs-consult-ripgrep-always-prompt-dir)
    ("M-s l" 'consult-line)
    ("M-s L" 'consult-line-multi)
    ("M-s m" 'consult-multi-occur)
    ("M-s k" 'consult-keep-lines)
    ("M-s u" 'consult-focus-lines)
    ;; Isearch integration
    ("M-s e" 'consult-isearch-history)
    (:keymaps 'isearch-mode-map
              [remap isearch-edit-string] 'consult-isearch-history
              "M-s L" 'consult-line-multi            ;; needed by consult-line to detect isearch
              )
    ;; Minibuffer history
    (:keymaps 'minibuffer-local-map
              [remap next-matching-history-element] 'consult-history
              [remap prev-matching-history-element] 'consult-history)

    ;; The :init configuration is always executed (Not lazy)
    :init

    ;; Optionally configure the register formatting. This improves the register
    ;; preview for `consult-register', `consult-register-load',
    ;; `consult-register-store' and the Emacs built-ins.

    ;; Optionally tweak the register preview window.
    ;; This adds thin lines, sorting and hides the mode line of the window.
    (advice-add #'register-preview :override #'consult-register-window)

    ;; Use Consult to select xref locations with preview
    (setq xref-show-xrefs-function #'consult-xref
          xref-show-definitions-function #'consult-xref)

    ;; Configure other variables and modes in the :config section,
    ;; after lazily loading the package.
    :custom
    (register-preview-delay 0.5)
    (register-preview-function #'consult-register-format)
    (consult-narrow-key "<") ;; (kbd "C-+")
    (consult-project-function (lambda (_) (projectile-project-root)))
    :config
    (setq consult--tofu-char #x100000)
    (setq consult--tofu-range #x00fffe)
    (defun pokemacs-consult-with-region (old-consult-function &optional dir given-initial)
      "Pass the region to consult-grep/ripgrep if available.

  DIR and GIVEN-INITIAL match the method signature of `consult-wrapper'."
      (interactive "P")
      (let ((initial
             (or given-initial
                 (when (use-region-p)
                   (buffer-substring-no-properties (region-beginning) (region-end))))))
        (funcall old-consult-function dir initial)))

    (advice-add #'consult-ripgrep :around #'pokemacs-consult-with-region)
    (advice-add #'consult-grep :around #'pokemacs-consult-with-region)

    (defun pokemacs-consult-ripgrep-always-prompt-dir ()
      (interactive)
      (consult-ripgrep t))

    (defun pokemacs-consult-git-grep-always-prompt-dir ()
      (interactive)
      (consult-git-grep t))

    (defvar pokemacs-consult-line-map
      (let ((map (make-sparse-keymap)))
        (define-key map "\C-s" #'previous-history-element)
        map))

    (defun consult-ripgrep-up-directory ()
      (interactive)
      (let ((parent-dir (file-name-directory (directory-file-name default-directory))))
        (when parent-dir
          (run-at-time 0 nil
                       #'consult-ripgrep
                       parent-dir
                       (ignore-errors
                         (buffer-substring-no-properties
                          (1+ (minibuffer-prompt-end)) (point-max))))))
      (minibuffer-quit-recursive-edit))

    (consult-customize
     consult-ripgrep
     :keymap (let ((map (make-sparse-keymap)))
               (define-key map (kbd "M-l") #'consult-ripgrep-up-directory)
               map))

    (consult-customize consult-line :keymap pokemacs-consult-line-map)
    ;; Optionally configure preview. The default value
    ;; is 'any, such that any key triggers the preview.
    ;; (setq consult-preview-key 'any)
    ;; (setq consult-preview-key (kbd "M-."))
    ;; (setq consult-preview-key (list (kbd "<S-down>") (kbd "<S-up>")))
    ;; For some commands and buffer sources it is useful to configure the
    ;; :preview-key on a per-command basis using the `consult-customize' macro.
    (consult-customize
     consult-theme :preview-key '(:debounce 0.2 any)

     consult-bookmark consult-recent-file
     consult-source-project-recent-file
     consult-source-recent-file consult-buffer
     consult-ripgrep consult-git-grep consult-grep
     pokemacs-consult-git-grep-always-prompt-dir
     pokemacs-consult-ripgrep-always-prompt-dir
     consult-xref consult-source-bookmark
     :preview-key '(:debounce 0.5 "M-."))

    ;; Optionally configure the narrowing key.
    ;; Both < and C-+ work reasonably well.

    ;; Optionally make narrowing help available in the minibuffer.
    ;; You may want to use `embark-prefix-help-command' or which-key instead.
    ;; (define-key consult-narrow-map (vconcat consult-narrow-key "?") #'consult-narrow-help)

    ;; By default `consult-project-function' uses `project-root' from project.el.
    ;; Optionally configure a different project root function.
    ;; There are multiple reasonable alternatives to chose from.
      ;;;; 1. project.el (the default)
    ;; (setq consult-project-function #'consult--default-project--function)
      ;;;; 2. projectile.el (projectile-project-root)
    (autoload 'projectile-project-root "projectile")
      ;;;; 3. vc.el (vc-root-dir)
    ;; (setq consult-project-function (lambda (_) (vc-root-dir)))
      ;;;; 4. locate-dominating-file
    ;; (setq consult-project-function (lambda (_) (locate-dominating-file "." ".git")))
    (message "`consult' loaded"))
#+end_src

** [[https://github.com/oantolin/embark][Embark]]
:PROPERTIES:
:CUSTOM_ID: embark
:END:

When using some consult commands (like ~consult-ripgrep~), hitting ~M-RET~ will jump to the result in the corresponding file without closing the minibuffer.

#+begin_src emacs-lisp
  (use-package embark
    :commands embark-collect
    :after (consult)
    :general
    ("C-." 'embark-act)          ;; pick some comfortable binding
    ("C-:" 'embark-default-act-noquit)  ;; good alternative: M-.
    ("C-h B" 'embark-bindings)   ;; alternative for `describe-bindings'
    :init
    ;; Optionally replace the key help with a completing-read interface
    (setq prefix-help-command #'embark-prefix-help-command)
    :custom
    (embark-quit-after-action nil)
    :config
    (defun embark-default-act-noquit ()
      (interactive)
      (let ((embark-quit-after-action nil))
        (embark-dwim)
        (when-let ((win (minibuffer-selected-window)))
          (select-window win))))

    ;; Hide the mode line of the Embark live/completions buffers
    (add-to-list 'display-buffer-alist
                 '("\\`\\*Embark Collect \\(Live\\|Completions\\)\\*"
                   nil
                   (window-parameters (mode-line-format . none))))
    (message "`embark' loaded"))

  ;; Consult users will also want the embark-consult package.
  (use-package embark-consult
    :after (embark consult)
    :hook
    (embark-collect-mode . consult-preview-at-point-mode)
    :config
    (message "`embark-consult' loaded"))
#+end_src

** [[https://github.com/minad/corfu][Corfu]]
:PROPERTIES:
:CUSTOM_ID: corfu
:END:

*** Main mode
:PROPERTIES:
:CUSTOM_ID: main-mode-5
:END:

#+begin_src emacs-lisp
  (use-package corfu
    ;; :ensure (corfu :ref "69f84fe" :files (:defaults "extensions/*"))
    :init
    ;; Function definitions
    (defun corfu-enable-always-in-minibuffer ()
      "Enable Corfu in the minibuffer if Vertico/Mct are not active."
      (unless (or (bound-and-true-p mct--active)
                  (bound-and-true-p vertico--input)
                  (eq (current-local-map) read-passwd-map))
        ;; (setq-local corfu-auto nil) ;; Enable/disable auto completion
        (setopt corfu-echo-delay nil ;; Disable automatic echo and popup
                corfu-popupinfo-delay nil)
        (corfu-mode 1)))

    (defun corfu-move-to-minibuffer ()
      (interactive)
      (when completion-in-region--data
        (let ((completion-extra-properties corfu--extra)
              completion-cycle-threshold completion-cycling)
          (apply #'consult-completion-in-region completion-in-region--data))))


    ;; Taken from https://www.reddit.com/r/emacs/comments/1l2fdu8/comment/mw3g9uo/
    (defun pokemacs--corfu--replace-a (func beg end str)
      "Replace the text between BEG and END with STR.

    This function checks if the replacement partially matches the text
    about to be replaced, and if so, deletes the duplicated part"

      (let* ((len (length str))
             (str-at-point (buffer-substring-no-properties beg (min (pos-eol) (+ beg len))))
             (len-similar (length (s-shared-start str str-at-point)))
             (len-diff (max 0 (- len-similar (- end beg)))))
        (funcall func beg end str)
        (delete-region end (+ end len-diff))))

    (advice-add 'corfu--replace :around #'pokemacs--corfu--replace-a)

    ;; Activate mode globally
    (global-corfu-mode)

    :general
    (:keymaps 'corfu-map
              "C-g" 'corfu-quit
              "<return>" 'corfu-insert
              "M-d" 'corfu-info-documentation
              "M-l" 'corfu-info-location
              "TAB" 'corfu-complete
              "M-SPC" 'corfu-insert-separator
              "M-m" 'corfu-move-to-minibuffer
              "<down>" 'corfu-next)
    :custom
    (corfu-cycle t)                ;; Enable cycling for `corfu-next/previous'
    (corfu-auto t)                 ;; Enable auto completion
    (corfu-quit-no-match t)
    (corfu-auto-prefix 1)
    (corfu-auto-delay 0.01)
    (corfu-separator ?\s)
    (corfu-history-mode t)
    ;; (corfu-quit-at-boundary nil)
    (corfu-on-exact-match nil)
    (corfu-echo-documentation t)
    (corfu-preview-current nil)    ;; Disable current candidate preview
    (corfu-preselect-first nil)    ;; Disable candidate preselection
    (corfu-min-width 80)
    (corfu-max-width 80)
    ;; (corfu-on-exact-match nil)     ;; Configure handling of exact matches
    ;; (corfu-echo-documentation nil) ;; Disable documentation in the echo area
    ;; (corfu-scroll-margin 5)        ;; Use scroll margin
    :config
    (add-hook 'minibuffer-setup-hook #'corfu-enable-always-in-minibuffer 1)
    (message "`corfu' loaded"))
#+end_src

*** Corfu-popupinfo
:PROPERTIES:
:CUSTOM_ID: corfu-popupinfo
:END:

#+begin_src emacs-lisp
  (use-package corfu-popupinfo
    :ensure nil
    :hook (corfu-mode . corfu-popupinfo-mode)
    :general
    (:keymaps 'corfu-popupinfo-map
              "M-h" 'corfu-popupinfo-toggle
              "M-<up>" 'scroll-other-window-down
              "M-<down>"   'scroll-other-window)
    :custom
    (corfu-echo-delay nil) ;; Disable automatic echo and popup
    (corfu-popupinfo-delay nil)
    (corfu-popupinfo-min-width 80)
    (corfu-popupinfo-max-width 80))
#+end_src

*** Corfu-prescient
:PROPERTIES:
:CUSTOM_ID: corfu-prescient
:END:

#+begin_src emacs-lisp
  (use-package corfu-prescient
    :demand t
    :after corfu prescient
    :custom
    ;; Sorting
    (corfu-prescient-enable-sorting t)
    (corfu-prescient-override-sorting nil) ; Don't override `display-sort-function'
    ;; Filtering
    (corfu-prescient-enable-filtering nil) ; We want orderless to do the filtering
    :config
    (corfu-prescient-mode 1)
    (message "`corfu-prescient' loaded"))
#+end_src

*** [[https://codeberg.org/akib/emacs-corfu-terminal][Corfu terminal]]
:PROPERTIES:
:CUSTOM_ID: corfu-terminal
:END:

This should be removed when childframes are implemented in terminal Emacs

#+begin_src emacs-lisp
  (use-package corfu-terminal
    :unless (display-graphic-p)
    :ensure (corfu-terminal :type git :repo "https://codeberg.org/akib/emacs-corfu-terminal.git")
    :init (corfu-terminal-mode +1))
#+end_src

*** [[https://codeberg.org/akib/emacs-corfu-doc-terminal][Corfu doc terminal]]
:PROPERTIES:
:CUSTOM_ID: corfu-doc-terminal
:END:

This should be removed when childframes are implemented in terminal Emacs
Need to fork this repo to make it work with the new corfu-popupinfo

#+begin_src emacs-lisp
  (use-package corfu-doc-terminal
    :disabled
    :unless (display-graphic-p)
    :ensure (corfu-doc-terminal :type git :repo "https://codeberg.org/akib/emacs-corfu-doc-terminal.git")
    :config (corfu-doc-terminal-mode +1))
#+end_src

** Emacs configuration for minibuffers and completion
:PROPERTIES:
:CUSTOM_ID: emacs-configuration-for-minibuffers-and-completion
:END:

#+begin_src emacs-lisp
  (use-package emacs
    :ensure nil
    :custom
    ;; FRINGE
    ;; UI: the gutter looks less cramped with some space between it and  buffer.
    (minibuffer-prompt-properties
     '(read-only t cursor-intangible t face minibuffer-prompt))
    (fringes-outside-margins nil)
    (describe-mode-outline nil)
    ;; Try to indent and if already indented, complete
    (tab-always-indent 'complete)
    ;; Emacs 28: Hide commands in M-x which do not work in the current mode.
    ;; Vertico commands are hidden in normal buffers.
    (read-extended-command-predicate #'command-completion-default-include-p)

    ;; Enable recursive minibuffers
    (enable-recursive-minibuffers t)
    :init
    ;; Add prompt indicator to `completing-read-multiple'.
    ;; We display [CRM<separator>], e.g., [CRM,] if the separator is a comma.
    (defun crm-indicator (args)
      (cons (format "[CRM%s] %s"
                    (replace-regexp-in-string
                     "\\`\\[.*?]\\*\\|\\[.*?]\\*\\'" ""
                     crm-separator)
                    (car args))
            (cdr args)))
    (advice-add #'completing-read-multiple :filter-args #'crm-indicator)

    ;; Do not allow the cursor in the minibuffer prompt
    (add-hook 'minibuffer-setup-hook #'cursor-intangible-mode)

    ;; (add-to-list 'completion-at-point-functions #'dabbrev-capf)
    (defun pokemacs-highlight-selected-window (&rest _)
      "Highlight selected window with a different background color."
      (with-current-buffer (window-buffer (selected-window))
        (buffer-face-set `(:background ,(face-attribute 'match :background)))
        (run-with-timer 0.1 nil #'buffer-face-set 'default)))
    (advice-add 'windmove-left :after #'pokemacs-highlight-selected-window)
    (advice-add 'windmove-right :after #'pokemacs-highlight-selected-window)
    (advice-add 'windmove-up :after #'pokemacs-highlight-selected-window)
    (advice-add 'windmove-down :after #'pokemacs-highlight-selected-window)
    :config
    (pretty-hydra-define
      pokemacs-toggles
      (:title "Toggles" :quit-key "q")
      ("Basic"
       (("n" nlinum-mode "line number" :toggle nlinum-mode)
        ("w" whitespace-mode "whitespace" :toggle whitespace-mode)
        ("r" rainbow-mode "rainbow" :toggle rainbow-mode)
        ("R" rainbow-delimiters-mode "rainbow delim" :toggle rainbow-delimiters-mode)
        ("L" global-page-break-lines-mode "page break lines" :toggle global-page-break-lines-mode))
       "Highlight"
       (("l" hl-line-mode "line" :toggle hl-line-mode)
        ("t" hl-todo-mode "todo" :toggle hl-todo-mode))
       "UI"
       (("d" pokemacs-toggle-theme "dark theme" :toggle (eq heaven-and-hell-theme-type 'dark))
        ("c" pokemacs-toggle-visual-fill "center buffer" :toggle pokemacs-visual-fill-enabled))
       "Coding"
       (("f" flycheck-mode "flycheck" :toggle flycheck-mode)
        ("i" flycheck-inline-mode "flycheck" :toggle flycheck-inline-mode)
        ("e" electric-indent-mode "indent" :toggle electric-indent-mode)
        ("k" pokemacs-toggle-completion-capf "complete keywords" :toggle pokemacs-complete-keywords))
       "Emacs"
       (("D" toggle-debug-on-error "debug on error" :toggle (default-value 'debug-on-error))
        ("X" toggle-debug-on-quit "debug on quit" :toggle (default-value 'debug-on-quit)))))
    (message "`emacs' loaded"))
#+end_src

** Windmove
:PROPERTIES:
:CUSTOM_ID: windmove
:END:

#+begin_src emacs-lisp
  (use-package windmove
    :ensure nil
    :general
    ;; windmove
    ("C-x <left>"              'windmove-left)
    ("C-x <right>"             'windmove-right)
    ("C-x <up>"                'windmove-up)
    ("C-x <down>"              'windmove-down)
    :bind
    (:repeat-map pokemacs-windmove-navigation-repeat-map
                 ("<left>" . 'windmove-left)
                 ("<right>" . 'windmove-right)
                 ("<up>" . 'windmove-up)
                 ("<down>" . 'windmove-down))
    :config
    (pokemacs-set-repeat-exit-timeout '(windmove-left windmove-up windmove-down windmove-right)))
#+end_src

** [[https://github.com/axelf4/hotfuzz][Hotfuzz]]
:PROPERTIES:
:CUSTOM_ID: hotfuzz
:END:

#+begin_src emacs-lisp
  (use-package hotfuzz
    :demand t
    :init
    (update-to-load-path pokemacs-hotfuzz-module-path)
    :ensure `(:post-build
              (("cmake" "-B" "build" "-DCMAKE_BUILD_TYPE=Release" "-DCMAKE_C_FLAGS=-march=native")
  	           ("cmake" "--build" "build")
               ("cp" "hotfuzz-module.so" ,pokemacs-hotfuzz-module-path)))
    :config
    (message "`hotfuzz' loaded %s" (when (featurep 'hotfuzz-module) "with `hotfuzz-module'")))
#+end_src

** [[https://github.com/oantolin/orderless][Orderless]]
:PROPERTIES:
:CUSTOM_ID: orderless
:END:

Better completions in minibuffers

#+begin_src emacs-lisp
  (use-package orderless
    :custom
    (orderless-matching-styles '(orderless-prefixes))
    (orderless-component-separator 'orderless-escapable-split-on-space)
    (read-file-name-completion-ignore-case t)
    (read-buffer-completion-ignore-case t)
    (completion-ignore-case t)
    (completion-category-defaults nil)
    (completion-category-overrides '((file (styles basic partial-completion))))
    :config (message "`orderless' loaded"))
#+end_src

** [[https://github.com/minad/cape][Cape]]
:PROPERTIES:
:CUSTOM_ID: cape
:END:

#+begin_src emacs-lisp
  (use-package cape
    :init (define-prefix-command 'pokemacs-cape-map nil "Cape-")
    :general
    ("M-c" 'pokemacs-cape-map)
    (:keymaps 'pokemacs-cape-map
              "p" 'completion-at-point ;; capf
              "t" 'complete-tag        ;; etags
              "d" 'cape-dabbrev        ;; or dabbrev-completion
              "h" 'cape-history
              "f" 'cape-file
              "k" 'cape-keyword
              "s" 'cape-symbol
              "a" 'cape-abbrev
              "i" 'cape-ispell
              "l" 'cape-line
              "w" 'cape-dict
              "\\" 'cape-tex
              "_" 'cape-tex
              "^" 'cape-tex
              "&" 'cape-sgml
              "r" 'cape-rfc1345)
    :init
    ;; Add `completion-at-point-functions', used by `completion-at-point'.
    (add-to-list 'completion-at-point-functions #'cape-file)

    (defun pokemacs--cape-dict-limited (&rest args)
      "Run cape-dict but limit results."
      (let ((result (apply #'cape-dict args)))
        (when result
          (cons (car result) (seq-take (cdr result) 2)))))

    ;; Defining capf for specific modes
    (defalias 'cape-?dict+keyword
      (if pokemacs-dict
          (cape-capf-super #'pokemacs--cape-dict-limited #'cape-keyword)
        (cape-capf-super #'cape-keyword)))

    :hook
    (org-mode . (lambda () (add-to-list 'completion-at-point-functions #'cape-elisp-block)))
    (git-commit-mode . (lambda () (add-to-list 'completion-at-point-functions #'cape-?dict+keyword)))
    (text-mode . (lambda () (add-to-list 'completion-at-point-functions #'cape-?dict+keyword))))
#+end_src

** [[https://github.com/minad/marginalia][Marginalia]]
:PROPERTIES:
:CUSTOM_ID: marginalia
:END:

Useful informations added in the minibuffer options

#+begin_src emacs-lisp
  (use-package marginalia
    :after vertico
    :init (marginalia-mode)
    :custom
    (marginalia-align 'center)
    (marginalia-align-offset -1)
    :config (message "`marginalia' loaded"))
#+end_src

** [[https://github.com/victorhge/iedit][Iedit]]
:PROPERTIES:
:CUSTOM_ID: iedit
:END:

#+begin_src emacs-lisp
  (use-package iedit
    :general
    (:keymaps 'lsp-mode-map
              "C-;" nil)
    :config (message "`iedit' loaded"))
#+end_src

** [[https://github.com/minad/tempel][Tempel]]
:PROPERTIES:
:CUSTOM_ID: tempel
:END:

#+begin_src emacs-lisp
  ;; Configure Tempel
  (use-package tempel
    ;; Require trigger prefix before template name when completing.
    :general
    ("M-+" 'tempel-complete) ;; Alternative tempel-expand
    ;; ("M-SPC" 'tempel-complete) ;; Alternative tempel-expand
    ("M-*" 'tempel-insert)
    (:keymaps 'tempel-map
              "RET" 'tempel-next)
    :init
    ;; Setup completion at point
    (defun tempel-setup-capf ()
      ;; Add the Tempel Capf to `completion-at-point-functions'.
      ;; `tempel-expand' only triggers on exact matches. Alternatively use
      ;; `tempel-complete' if you want to see all matches, but then you
      ;; should also configure `tempel-trigger-prefix', such that Tempel
      ;; does not trigger too often when you don't expect it. NOTE: We add
      ;; `tempel-expand' *before* the main programming mode Capf, such
      ;; that it will be tried first.
      (setq-local completion-at-point-functions
                  (cons #'tempel-expand
                        completion-at-point-functions)))

    (add-hook 'text-mode-hook 'tempel-setup-capf)

    ;; Optionally make the Tempel templates available to Abbrev,
    ;; either locally or globally. `expand-abbrev' is bound to C-x '.
    ;; (add-hook 'prog-mode-hook #'tempel-abbrev-mode)
    ;; (global-tempel-abbrev-mode)
    :config
    (put 'tempel-template-sources 'permanent-local t))

  ;; Optional: Add tempel-collection.
  ;; The package is young and doesn't have comprehensive coverage.
  (use-package tempel-collection)
#+end_src

* GUI
:PROPERTIES:
:CUSTOM_ID: gui
:END:

** Mode-line
:PROPERTIES:
:CUSTOM_ID: mode-line
:END:

*** [[https://github.com/emacsorphanage/anzu][Anzu]]
:PROPERTIES:
:CUSTOM_ID: anzu
:END:

Displays a counter in the mode-line when searching or query replacing.

#+begin_src emacs-lisp
  (use-package anzu
    :init
    (global-anzu-mode +1)
    (anzu-mode +1)
    :config
    (global-set-key [remap query-replace] 'anzu-query-replace)
    (global-set-key [remap query-replace-regexp] 'anzu-query-replace-regexp)
    (define-key isearch-mode-map [remap isearch-query-replace]  #'anzu-isearch-query-replace)
    (define-key isearch-mode-map [remap isearch-query-replace-regexp] #'anzu-isearch-query-replace-regexp)
    (message "`anzu' loaded"))
#+end_src

*** [[https://github.com/seagle0128/doom-modeline][Doom modeline]]
:PROPERTIES:
:CUSTOM_ID: doom-modeline
:END:

This mode allows to customize entirely the emacs mode-line. Two mode-lines are defined here, one when lsp-mode is active and one when it isn't since lsp-mode already displays informations that would be redundant with the default mode-line.

Read the comments in the code if you want to understand its configuration.

Some customization is available from [[file:custom.el][custom.el]], mainly ~doom-modeline-bar-width~ and ~doom-modeline-height~.

#+begin_src emacs-lisp
  (defcustom pokemacs-mode-line-right-align 'right-fringe
    "See https://github.com/seagle0128/doom-modeline/issues/672.
     Original value is 'window"
    :group 'pokemacs-appearance
    :type 'symbol
    :tag " Modeline")

  (use-package doom-modeline
    :demand t
    :init
    ;; If non-nil, cause imenu to see `doom-modeline' declarations.
    ;; This is done by adjusting `lisp-imenu-generic-expression' to
    ;; include support for finding `doom-modeline-def-*' forms.
    ;; Must be set before loading doom-modeline.
    (setopt doom-modeline-support-imenu t)
    :custom
    ;; I don't care about the percentage position of the cursor
    (mode-line-percent-position nil)
    (mode-line-right-align-edge pokemacs-mode-line-right-align)
    ;; Whether to use hud instead of default bar. It's only respected in GUI.
    (doom-modeline-hud nil)

    ;; The limit of the window width.
    ;; If `window-width' is smaller than the limit, some information won't be
    ;; displayed. It can be an integer or a float number. `nil' means no limit.
    (doom-modeline-window-width-limit 85)

    ;; How to detect the project root.
    ;; nil means to use `default-directory'.
    ;; The project management packages have some issues on detecting project root.
    ;; e.g. `projectile' doesn't handle symlink folders well, while `project' is unable
    ;; to hanle sub-projects.
    ;; You can specify one if you encounter the issue.
    (doom-modeline-project-detection 'projectile)

    ;; Determines the style used by `doom-modeline-buffer-file-name'.
    ;;
    ;; Given ~/Projects/FOSS/emacs/lisp/comint.el
    ;;   auto => emacs/l/comint.el (in a project) or comint.el
    ;;   truncate-upto-project => ~/P/F/emacs/lisp/comint.el
    ;;   truncate-from-project => ~/Projects/FOSS/emacs/l/comint.el
    ;;   truncate-with-project => emacs/l/comint.el
    ;;   truncate-except-project => ~/P/F/emacs/l/comint.el
    ;;   truncate-upto-root => ~/P/F/e/lisp/comint.el
    ;;   truncate-all => ~/P/F/e/l/comint.el
    ;;   truncate-nil => ~/Projects/FOSS/emacs/lisp/comint.el
    ;;   relative-from-project => emacs/lisp/comint.el
    ;;   relative-to-project => lisp/comint.el
    ;;   file-name => comint.el
    ;;   buffer-name => comint.el<2> (uniquify buffer name)
    ;;
    ;; If you are experiencing the laggy issue, especially while editing remote files
    ;; with tramp, please try `file-name' style.
    ;; Please refer to https://github.com/bbatsov/projectile/issues/657.
    (doom-modeline-buffer-file-name-style 'truncate-all)

    ;; Whether display icons in the mode-line.
    ;; While using the server mode in GUI, should set the value explicitly.
    (doom-modeline-icon t)

    ;; Whether display the colorful icon for `major-mode'.
    ;; It respects `all-the-icons-color-icons'.
    (doom-modeline-major-mode-color-icon t)

    ;; Whether display the icon for the buffer state. It respects `doom-modeline-icon'.
    (doom-modeline-buffer-state-icon t)

    ;; Whether display the modification icon for the buffer.
    ;; It respects `doom-modeline-icon' and `doom-modeline-buffer-state-icon'.
    (doom-modeline-buffer-modification-icon t)

    ;; Whether to use unicode as a fallback (instead of ASCII) when not using icons.
    (doom-modeline-unicode-fallback t)

    ;; Major modes in which to display word count continuously.
    ;; Also applies to any derived modes. Respects `doom-modeline-enable-word-count'.
    ;; If it brings the sluggish issue, disable `doom-modeline-enable-word-count' or
    ;; remove the modes from `doom-modeline-continuous-word-count-modes'.
    (doom-modeline-continuous-word-count-modes '(markdown-mode gfm-mode org-mode))

    ;; If non-nil, only display one number for check information if applicable.
    (doom-modeline-check-simple-format nil)

    ;; The maximum number displayed for notifications.
    (doom-modeline-number-limit 99)

    ;; The maximum displayed length of the branch name of version control.
    (doom-modeline-vcs-max-length 12)

    ;; Whether display the minions minor mode
    (doom-modeline-minor-modes t)

    ;; Whether display the mu4e notifications
    (doom-modeline-mu4e nil)

    ;; Whether display the GitHub notifications. It requires `ghub' package.
    (doom-modeline-github nil)

    ;; The interval of checking GitHub.
    (doom-modeline-github-interval 30)

    ;; Whether display the environment version.
    (doom-modeline-env-version t)
    ;; Or for individual languages
    (doom-modeline-env-enable-python t)
    (doom-modeline-env-enable-ruby t)
    (doom-modeline-env-enable-perl t)
    (doom-modeline-env-enable-go t)
    (doom-modeline-env-enable-elixir t)
    (doom-modeline-env-enable-rust t)

    ;; Change the executables to use for the language version string
    (doom-modeline-env-python-executable "python") ; or `python-shell-interpreter'
    (doom-modeline-env-ruby-executable "ruby")
    (doom-modeline-env-perl-executable "perl")
    (doom-modeline-env-go-executable "go")
    (doom-modeline-env-elixir-executable "iex")
    (doom-modeline-env-rust-executable "rustc")

    ;; What to display as the version while a new one is being loaded
    (doom-modeline-env-load-string "...")


    :config
    ;; Define your custom doom-modeline
    (doom-modeline-def-modeline 'pokemacs-no-lsp-line
      '(bar " " matches follow buffer-info modals remote-host buffer-position word-count parrot selection-info)
      '(misc-info persp-name grip debug minor-modes major-mode process vcs check))

    (doom-modeline-def-modeline 'pokemacs-lsp-line
      '(" " matches follow lsp modals remote-host buffer-position word-count parrot selection-info)
      '(misc-info persp-name grip debug minor-modes major-mode process vcs check))

    (defun pokemacs-mode-line-to-header-line ()
      (when use-header-line
        (setq header-line-format mode-line-format)
        (setq mode-line-format nil)))

    ;; Add to `doom-modeline-mode-hook` or other hooks
    (defun pokemacs-setup-no-lsp-doom-modeline ()
      (message "doom no lsp modeline change")
      (doom-modeline-set-modeline 'pokemacs-no-lsp-line 'default)
      (pokemacs-mode-line-to-header-line))

    (defun pokemacs-setup-lsp-doom-modeline ()
      (message "doom lsp modeline change")
      (lsp-headerline-breadcrumb-mode -1)
      (doom-modeline-set-modeline 'pokemacs-lsp-line nil)
      (pokemacs-mode-line-to-header-line)
      (lsp-headerline-breadcrumb-mode 1))

    ;; Redefine all the mouse interactions of the modeline to the headerline
    (add-hook 'doom-modeline-mode-hook 'pokemacs-setup-no-lsp-doom-modeline)
    (add-hook 'lsp-mode-hook 'pokemacs-setup-lsp-doom-modeline)
    (doom-modeline-mode)
    (when use-header-line
      (define-key mode-line-major-mode-keymap [header-line]
                  (lookup-key mode-line-major-mode-keymap [mode-line]))
      (define-key mode-line-minor-mode-keymap [header-line]
                  (lookup-key mode-line-minor-mode-keymap [mode-line])))
    (message "`doom-modeline' loaded"))
#+end_src

*** [[https://github.com/tarsius/minions][Minions]]
:PROPERTIES:
:CUSTOM_ID: minions
:END:

Implements a menu that lists enabled and disabled minor modes in the mode-line.

#+begin_src emacs-lisp
  (use-package minions
    :demand t
    :config (minions-mode)
    :custom
    (minions-mode-line-lighter "☰")
    ;; :general
    ;; (:keymaps 'minions-mode-line-minor-modes-map
    ;;           "<mode-line> <mouse-1>" 'minions-minor-modes-menu)
    :config (message "`minions' loaded"))
#+end_src

** [[https://www.emacswiki.org/emacs/OutlineMinorMode][Outline]] (major and minor modes)
:PROPERTIES:
:CUSTOM_ID: outline-major-and-minor-modes
:END:

*** Major mode
:PROPERTIES:
:CUSTOM_ID: major-mode
:END:

#+begin_src emacs-lisp
  (use-package outline
    :ensure nil
    :general
    ("C-o" 'cm-map)
    (:keymaps 'cm-map
              ;; HIDE
              "q" '("Hide everything but the top-level headings" . outline-hide-sublevels)
              "t" '("Hide everything but headings (all body lines" . outline-hide-body)
              "o" '("Hide other branche" . outline-hide-other)
              "c" '("Hide this entry's bod" . outline-hide-entry)
              "l" '("Hide body lines in this entry and sub-entrie" . outline-hide-leaves)
              "d" '("Hide everything in this entry and sub-entrie" . outline-hide-subtree)
              ;; SHOW
              "a" '("Show (expand) everythin" . outline-show-all)
              "e" '("Show this heading's bod" . outline-show-entry)
              "i" '("Show this heading's immediate child sub-heading" . outline-show-children)
              "k" '("Show all sub-headings under this headin" . outline-show-branches)
              "s" '("Show (expand) everything in this heading & belo" . outline-show-subtree)
              ;; MOVE
              "u" '("U" . outline-up-heading)
              "n" '("Nex" . outline-next-visible-heading)
              "p" '("Previou" . outline-previous-visible-heading)
              "f" '("Forward - same leve" . outline-forward-same-level)
              "b" '("Backward - same leve" . outline-backward-same-level)
              )
    :config
    (define-prefix-command 'cm-map nil "Outline-")
    (set-display-table-slot standard-display-table
                            'selective-display
                            (string-to-vector "+++"))

    (message "`outline' loaded"))
#+end_src

** [[https://github.com/emacsmirror/rainbow-mode][Rainbow mode]]
:PROPERTIES:
:CUSTOM_ID: rainbow-mode
:END:

Display colors with a background corresponding to the color

#+begin_src emacs-lisp
  (use-package rainbow-mode
    :hook (help-mode prog-mode text-mode org-mode)
    :config (message "`rainbow-mode' loaded"))
#+end_src

** [[https://github.com/Fanael/rainbow-delimiters][Rainbow delimiters]]
:PROPERTIES:
:CUSTOM_ID: rainbow-delimiters
:END:

Different colours for different depths of parentheses, brackets etc

#+begin_src emacs-lisp
  (if use-rainbow
      (use-package rainbow-delimiters
        :hook (prog-mode . rainbow-delimiters-mode)
        :config (message "`rainbow-delimiters' loaded")))
#+end_src

** [[https://github.com/protesilaos/pulsar][Pulsar]]
:PROPERTIES:
:CUSTOM_ID: pulsar
:END:

Will pulse when the focus changes to show where the cursor is.

#+begin_src emacs-lisp
  (use-package pulsar
    :custom
    (pulsar-pulse-functions
     '(recenter-top-bottom
       move-to-window-line-top-bottom
       reposition-window
       forward-page
       backward-page
       scroll-up-command
       scroll-down-command
       org-next-visible-heading
       org-previous-visible-heading
       org-forward-heading-same-level
       org-backward-heading-same-level
       outline-backward-same-level
       outline-forward-same-level
       outline-next-visible-heading
       outline-previous-visible-heading
       outline-up-heading
       ))

    (pulsar-pulse-on-window-change t)
    (pulsar-pulse t)
    (pulsar-delay 0.055)
    (pulsar-iterations 10)
    (pulsar-face 'pulsar-magenta)
    (pulsar-highlight-face 'pulsar-yellow)
    :config
    (pulsar-global-mode 1)
    (message "`pulsar' loaded"))
#+end_src

** [[https://github.com/hlissner/emacs-solaire-mode][Solaire]]
:PROPERTIES:
:CUSTOM_ID: solaire
:END:

#+begin_src emacs-lisp
  (when use-solaire
    (use-package solaire-mode
      :config
      (solaire-global-mode +1)
      (message "`solaire' loaded")))
#+end_src

** [[https://github.com/emacs-dashboard/emacs-dashboard][Dashboard]]
:PROPERTIES:
:CUSTOM_ID: dashboard
:END:

#+begin_src emacs-lisp
  (when use-dashboard
    (use-package page-break-lines
      :config (message "`page-break-lines' loaded"))

    (use-package dashboard
      :custom
      ;; Set the title
      (dashboard-banner-logo-title "Pokemacs")
      ;; ;; Set the banner
      (dashboard-startup-banner "~/.emacs.d/etc/dashboard/calvin_hobbes.jpeg")
      (dashboard-center-content t)
      (dashboard-set-heading-icons t)
      (dashboard-icon-type (if use-all-the-icons 'all-the-icons 'nerd-icons))
      (dashboard-display-icons-p (if use-all-the-icons nil t))
      (dashboard-set-file-icons t)
      (dashboard-items '((recents  . 5)
                         (bookmarks . 5)
                         (projects . 5)
                         (agenda . 5)))
      (dashboard-set-navigator t)
      (dashboard-set-footer nil)
      (dashboard-week-agenda t)
      (dashboard-init-info
       (lambda ()
         (let ((package-count 0) (time (emacs-init-time)))
           (when (fboundp 'elpaca--queued)
             (setq time (format "%f seconds" (float-time (time-subtract elpaca-after-init-time
                                                                        before-init-time))))
             (setq package-count (length (elpaca--queued))))
           (if (zerop package-count)
               (format "Emacs started in %s with %s gc" time gcs-done)
             (format "%d packages loaded in %s with %s gc" package-count time gcs-done)))))
      :hook
      (elpaca-after-init . dashboard-insert-startupify-lists)
      (elpaca-after-init . dashboard-initialize)
      :config
      (dashboard-setup-startup-hook)
      (message "`dashboard' loaded")))
#+end_src

* [[https://github.com/emacs-eaf/emacs-application-framework][EAF]]
:PROPERTIES:
:CUSTOM_ID: eaf
:END:

#+begin_src emacs-lisp
  (when use-eaf
    (use-package eaf
      :load-path "lisp/emacs-application-framework"
      :ensure nil
      :custom
      ;; See https://github.com/emacs-eaf/emacs-application-framework/wiki/Customization
      (eaf-browser-continue-where-left-off t)
      (eaf-browser-enable-adblocker t)
      ;; (browse-url-browser-function 'eaf-open-browser)
      (eaf-browser-default-search-engine "duckduckgo")
      :config
      (require 'eaf-all-the-icons)
      (require 'eaf-org)
      (require 'eaf-browser)
      ;; (require 'eaf-pdf-viewer)
      (require 'eaf-system-monitor)
      (require 'eaf-image-viewer)
      (require 'eaf-markdown-previewer)
      (require 'eaf-org-previewer)
      (require 'eaf-demo)

      (defalias 'browse-web #'eaf-open-browser)
      ;; (eaf-bind-key scroll_up "C-n" eaf-pdf-viewer-keybinding)
      ;; (eaf-bind-key scroll_down "C-p" eaf-pdf-viewer-keybinding)
      (eaf-bind-key nil "M-q" eaf-browser-keybinding)
      (message "`eaf' loaded"))) ;; unbind, see more in the Wiki
#+end_src

* [[https://github.com/emacs-tree-sitter/elisp-tree-sitter][Tree sitter]]
:PROPERTIES:
:CUSTOM_ID: tree-sitter
:END:

** Treesit
:PROPERTIES:
:CUSTOM_ID: treesit
:END:

*** Main Mode
:PROPERTIES:
:CUSTOM_ID: main-mode-6
:END:

#+begin_src emacs-lisp
  (use-package treesit
    :demand t
    :ensure nil
    :config (message "`treesit' loaded"))
#+end_src

*** Treesit-auto
:PROPERTIES:
:CUSTOM_ID: treesit-auto
:END:

There's currently a bug where if grammars were already installed new ones can't be installed. Use ~pokemacs-fix-treesit-auto~ to install a missing grammar.

#+begin_src emacs-lisp
  (use-package treesit-auto
    :demand t
    :init
    (defun pokemacs-fix-treesit-auto (lang)
      (interactive
       (let ((langs treesit-auto-langs))
         (list (completing-read "Lang: " langs))))
      (let ((treesit-auto-langs `(,(intern lang))))
        (treesit-auto-install-all)))
    :custom
    (treesit-auto-install 'prompt)
    :config
    (setq pokemacs-ocaml-tsauto-config
          (make-treesit-auto-recipe
           :lang 'ocaml
           :ts-mode 'tuareg-mode
           :remap '(tuareg-mode)
           :url "https://github.com/tree-sitter/tree-sitter-ocaml"
           :revision "v0.24.1"
           :source-dir "grammars/ocaml/src"
           :ext "\\.ml\\'"))
    (setq pokemacs-elisp-tsauto-config
          (make-treesit-auto-recipe
           :lang 'elisp
           :ts-mode 'emacs-lisp-mode
           :remap '(emacs-lisp-mode)
           :url "https://github.com/Wilfred/tree-sitter-elisp"
           :revision "main"
           :ext "\\.el\\'"))
    (setq pokemacs-zig-tsauto-config
          (make-treesit-auto-recipe
           :lang 'zig
           :ts-mode 'zig-ts-mode
           :remap 'zig-mode
           :url "https://github.com/maxxnino/tree-sitter-zig"
           :ext "\\.zig\\'"))

    ;; Add OCaml to treesit parsers even if tuareg can't handle it
    (add-to-list 'treesit-auto-recipe-list pokemacs-ocaml-tsauto-config)
    (add-to-list 'treesit-auto-recipe-list pokemacs-elisp-tsauto-config)
    (add-to-list 'treesit-auto-recipe-list pokemacs-zig-tsauto-config)
    (setq treesit-auto-langs (remove 'markdown treesit-auto-langs))
    (treesit-auto-add-to-auto-mode-alist 'all)
    (global-treesit-auto-mode)
    (message "`treesit-auto' loaded"))
#+end_src

** Tree sitter elisp
:PROPERTIES:
:CUSTOM_ID: tree-sitter-elisp
:END:

Minor mode that uses tree-sitter, an incremental parsing library. As well as LSP use incremental compilation to give useful informations about programs, tree-sitter use incremental parsing of current buffer to help with syntax highlighting, code folding etc.

*** Main mode
:PROPERTIES:
:CUSTOM_ID: main-mode-7
:END:

#+begin_src emacs-lisp
  ;; This package needs to be loaded to use language parsers
  (use-package tree-sitter-langs
    :config (message "`tree-sitter-langs' loaded"))

  (use-package tree-sitter
    :hook
    (tuareg-mode . tree-sitter-mode)
    (tree-sitter-after-on . tree-sitter-hl-mode)
    :custom
    ;; This makes every node a link to a section of code
    (tree-sitter-debug-jump-buttons t)
    ;; and this highlights the entire sub tree in your code
    (tree-sitter-debug-highlight-jump-region t)
    ;; (global-tree-sitter-mode)
    :config (message "`tree-sitter' loaded"))

  ;; (use-package tree-sitter-hl
  ;;   :ensure nil
  ;;   :config
  ;;   (defvar pokemacs--tree-sitter-hl-faces
  ;;     '(tree-sitter-hl-face:keyword
  ;;       tree-sitter-hl-face:doc
  ;;       tree-sitter-hl-face:tag
  ;;       tree-sitter-hl-face:type
  ;;       tree-sitter-hl-face:label
  ;;       tree-sitter-hl-face:escape
  ;;       tree-sitter-hl-face:number
  ;;       tree-sitter-hl-face:method
  ;;       tree-sitter-hl-face:string
  ;;       tree-sitter-hl-face:comment
  ;;       tree-sitter-hl-face:embedded
  ;;       tree-sitter-hl-face:variable
  ;;       tree-sitter-hl-face:property
  ;;       tree-sitter-hl-face:operator
  ;;       tree-sitter-hl-face:function
  ;;       tree-sitter-hl-face:constant
  ;;       tree-sitter-hl-face:attribute
  ;;       tree-sitter-hl-face:type.super
  ;;       tree-sitter-hl-face:method.call
  ;;       tree-sitter-hl-face:punctuation
  ;;       tree-sitter-hl-face:constructor
  ;;       tree-sitter-hl-face:type.builtin
  ;;       tree-sitter-hl-face:function.call
  ;;       tree-sitter-hl-face:type.argument
  ;;       tree-sitter-hl-face:function.macro
  ;;       tree-sitter-hl-face:type.parameter
  ;;       tree-sitter-hl-face:string.special
  ;;       tree-sitter-hl-face:constant.builtin
  ;;       tree-sitter-hl-face:function.builtin
  ;;       tree-sitter-hl-face:function.special
  ;;       tree-sitter-hl-face:variable.special
  ;;       tree-sitter-hl-face:variable.builtin
  ;;       tree-sitter-hl-face:variable.parameter
  ;;       tree-sitter-hl-face:property.definition
  ;;       tree-sitter-hl-face:punctuation.special
  ;;       tree-sitter-hl-face:punctuation.bracket
  ;;       tree-sitter-hl-face:punctuation.delimiter))
  ;;   (pokemacs--populate-font-lock-faces-plist pokemacs--tree-sitter-hl-faces)
  ;;   (pokemacs-load-theme))
#+end_src

*** Tree sitter folding
:PROPERTIES:
:CUSTOM_ID: tree-sitter-folding
:END:

Code folding based on treesit.el tree.

#+begin_src emacs-lisp
  (use-package treesit-fold
    :ensure (treesit-fold :type git :host github :repo "emacs-tree-sitter/treesit-fold")
    :general
    ("<backtab>" 'treesit-fold-toggle)
    :hook
    (emacs-lisp-mode . (lambda ()
                         (pokemacs-fix-treesit-auto "elisp")
                         (treesit-parser-create 'elisp)))
    (tuareg-mode . (lambda ()
                     (pokemacs-fix-treesit-auto "ocaml")
                     (treesit-parser-create 'ocaml)))
    (c-mode . (lambda () (treesit-parser-create 'c)))
    :custom
    ;; (treesit-fold-replacement "  [...]  ")
    (treesit-fold-line-count-show t)
    :config
    (global-treesit-fold-mode)
    (message "`treesit-fold' loaded"))

  (use-package treesit-fold-indicators
    :ensure nil
    :custom
    (treesit-fold-indicators-fringe 'left-fringe)
    (treesit-fold-indicators-priority 100)
    :config
    (global-treesit-fold-indicators-mode)
    (message "`ts-fold-indicators' loaded"))

#+end_src

** [[https://github.com/mattiasdrp/combobulate][Combobulate]]
:PROPERTIES:
:CUSTOM_ID: combobulate
:END:

#+begin_src emacs-lisp
  (use-package combobulate
    :disabled
    :after treesit
    :preface
    ;; You can customize Combobulate's key prefix here.
    ;; Note that you may have to restart Emacs for this to take effect!
    (setq combobulate-key-prefix "C-c c")
    :hook
    ((python-ts-mode . combobulate-mode)
     (js-ts-mode . combobulate-mode)
     (html-ts-mode . combobulate-mode)
     (css-ts-mode . combobulate-mode)
     (yaml-ts-mode . combobulate-mode)
     (typescript-ts-mode . combobulate-mode)
     (json-ts-mode . combobulate-mode)
     (tsx-ts-mode . combobulate-mode))
    ;; Amend this to the directory where you keep Combobulate's source
    ;; code.
    :load-path "lisp/combobulate")
#+end_src

* Programming languages
:PROPERTIES:
:CUSTOM_ID: programming-languages
:END:

** Enable/Disable packages related to languages
:PROPERTIES:
:CUSTOM_ID: enabledisable-packages-related-to-languages
:END:

#+begin_src emacs-lisp
  (defgroup pokemacs-languages nil
    "Pokemacs languages options."
    :group 'pokemacs
    :tag "Languages")

  (defcustom use-clojure nil
    "If non-nil, uses the Clojure packages."
    :group 'pokemacs-languages
    :type 'boolean
    :tag " Clojure")

  (defcustom use-elm nil
    "If non-nil, uses the Elm packages."
    :group 'pokemacs-languages
    :type 'boolean
    :tag " Elm")

  (defcustom use-fsharp nil
    "If non-nil, uses the F# packages."
    :group 'pokemacs-languages
    :type 'boolean
    :tag " F#")

  (defcustom use-go nil
    "If non-nil, uses the Go packages."
    :group 'pokemacs-languages
    :type 'boolean
    :tag " Go")

  (defcustom use-kotlin nil
    "If non-nil, uses the Kotlin packages."
    :group 'pokemacs-languages
    :type 'boolean
    :tag " Kotlin")

  (defcustom use-java nil
    "If non-nil, uses the Java packages."
    :group 'pokemacs-languages
    :type 'boolean
    :tag " Java")

  (defcustom use-latex nil
    "If non-nil, uses the LaTeX packages."
    :group 'pokemacs-languages
    :type 'boolean
    :tag "LaTeX")

  (defcustom use-markdown nil
    "If non-nil, uses the markdown packages."
    :group 'pokemacs-languages
    :type 'boolean
    :tag " Markdown")

  (defcustom use-michelson nil
    "If non-nil, uses the michelson packages."
    :group 'pokemacs-languages
    :type 'boolean
    :tag "Michelson")

  (defcustom use-ocaml t
    "If non-nil, uses the OCaml packages."
    :group 'pokemacs-languages
    :type 'boolean
    :tag " OCaml")

  (defcustom use-python nil
    "If non-nil, uses the Python packages."
    :group 'pokemacs-languages
    :type 'boolean
    :tag " Python")

  (defcustom use-racket nil
    "If non-nil, uses the Racket packages."
    :group 'pokemacs-languages
    :type 'boolean
    :tag "󰘧 Racket")

  (defcustom use-reason nil
    "If non-nil, uses the Reason packages."
    :group 'pokemacs-languages
    :type 'boolean
    :tag " ReasonML")

  (defcustom use-ruby t
    "If non-nil, uses the Ruby packages."
    :group 'pokemacs-languages
    :type 'boolean
    :tag " Ruby")

  (defcustom use-rust nil
    "If non-nil, uses the rust packages."
    :group 'pokemacs-languages
    :type 'boolean
    :tag " Rust")

  (defcustom use-sicp nil
    "If non-nil, uses the sicp related packages."
    :group 'pokemacs-languages
    :type 'boolean
    :tag "󰘧 SICP")

  (defcustom use-web nil
    "If non-nil, uses the web packages."
    :group 'pokemacs-languages
    :type 'boolean
    :tag " Web")

  (defcustom use-zig nil
    "If non-nil, uses the zig packages."
    :group 'pokemacs-languages
    :type 'boolean
    :tag " Zig")
#+end_src

** Markdown
:PROPERTIES:
:CUSTOM_ID: markdown
:END:

**** [[https://github.com/jrblevin/markdown-mode][Main mode]]
:PROPERTIES:
:CUSTOM_ID: main-mode-8
:END:

#+begin_src emacs-lisp
  (when use-markdown
    (use-package markdown-mode
      :ensure t
      :mode (("README\\.md\\'" . gfm-mode)
             ("\\.md\\'"       . markdown-mode)
             ("\\.markdown\\'" . gfm-mode))
      :hook (gfm-mode . (lambda ()
                          (setq-local markdown-command "pandoc --metadata title:Title -t html5 --css ~/markdown_css/github-markdown-dark.css -f gfm -s")))
      :general (:keymaps 'markdown-mode-map
                         "C-c C-e" 'markdown-do)
      :config
      (require 'lsp-marksman)
      (setq markdown-command "markdown")
      (setq markdown-open-command "retext")
      (message "`markdown-mode' loaded")))
#+end_src

**** LSP-marksman
:PROPERTIES:
:CUSTOM_ID: lsp-marksman
:END:

#+begin_src emacs-lisp
  (when use-markdown
    (use-package lsp-marksman
      :ensure nil
      :hook
      (markdow-mode . lsp-deferred)))
#+end_src

**** [[https://github.com/ardumont/markdown-toc][Markdown toc]]
:PROPERTIES:
:CUSTOM_ID: markdown-toc
:END:

#+begin_src emacs-lisp
  (when use-markdown
    (use-package markdown-toc
      :config (message "`markdown-toc' loaded")))
#+end_src

**** [[https://github.com/joostkremers/pandoc-mode][Pandoc]]
:PROPERTIES:
:CUSTOM_ID: pandoc
:END:

#+begin_src emacs-lisp
  (when use-pandoc
    (use-package pandoc-mode
      :ensure-system-package pandoc
      :hook ((markdown-mode . pandoc-mode)
             (pandoc-mode . pandoc-load-default-settings))
      :config (message "`pandoc-mode' loaded")))
#+end_src

** Data/Config formats
:PROPERTIES:
:CUSTOM_ID: dataconfig-formats
:END:

*** Conf mode
:PROPERTIES:
:CUSTOM_ID: conf-mode
:END:

Mode for editing config files.

This mode will install ~taplo~ through ~cargo~ if it's not already installed to manage toml files with lsp-mode.


#+begin_src emacs-lisp
  (use-package conf-mode
    :ensure nil
    :mode (
           ("/\\.merlin\\'" . conf-mode)
           ("_tags\\'" . conf-mode)
           ("_log\\'" . conf-mode)
           ("\\.toml\\'" . conf-toml-mode)
           )
    :config (message "`conf-mode' loaded"))
#+end_src

*** [[https://github.com/joshwnj/json-mode][Json-mode]]
:PROPERTIES:
:CUSTOM_ID: json-mode
:END:

#+begin_src emacs-lisp
  (use-package json-mode
    :mode (("\\.bowerrc$"     . json-mode)
           ("\\.jshintrc$"    . json-mode)
           ("\\.json_schema$" . json-mode)
           ("\\.json\\'"      . json-mode))
    :general
    (:keymaps 'json-mode-map
              "C-c <tab>" 'json-mode-beautify
              "<tab>" 'hs-toggle-hiding
              "C-c C-a" 'hs-show-all
              "C-c C-t" 'hs-hide-all
              "C-c C-l" 'hs-hide-level
              )
    :config
    (make-local-variable 'js-indent-level)
    (message "`json-mode' loaded"))
#+end_src

*** Dune files
:PROPERTIES:
:CUSTOM_ID: dune-files
:END:

#+begin_src emacs-lisp
  (use-package dune
    :mode ("^dune$" "^dune-project$")
    :general
    (:keymaps 'dune-mode-map
              :prefix "C-d"
              "C-c" 'compile
              "l" 'dune-insert-library-form
              "e" 'dune-insert-executable-form
              "x" 'dune-insert-executables-form
              "r" 'dune-insert-rule-form
              "p" 'dune-insert-ocamllex-form
              "y" 'dune-insert-ocamlyacc-form
              "m" 'dune-insert-menhir-form
              "a" 'dune-insert-alias-form
              "i" 'dune-insert-install-form
              "c" 'dune-insert-copyfiles-form
              "t" 'dune-insert-tests-form
              "v" 'dune-insert-env-form
              "d" 'dune-insert-ignored-subdirs-form)
    :config (message "`dune' loaded"))
#+end_src

*** Makefile
:PROPERTIES:
:CUSTOM_ID: makefile
:END:

#+begin_src emacs-lisp
  (use-package make-mode
    :ensure nil
    :hook (make-mode . semantic-mode)
    :config (message "`make-mode' loaded"))
#+end_src

** Bash-ts-mode
:PROPERTIES:
:CUSTOM_ID: bash-ts-mode
:END:

#+begin_src emacs-lisp
  (use-package bash-ts-mode
    :ensure nil
    :hook (bash-ts-mode .
                        (lambda ()
                          (unless (executable-find "shfmt")
                            (display-warning 'bash-ts-mode
                                             (format-message "`shfmt' is not installed. You can install it with either:
    - `sudo apt -y install shfmt'
    - `sudo pacman -S shfmt'
    - `curl -sS https://webinstall.dev/shfmt | bash'
    - etc") :warning)))))
#+end_src

** C/C++
:PROPERTIES:
:CUSTOM_ID: cc
:END:

*** Main mode
:PROPERTIES:
:CUSTOM_ID: main-mode-9
:END:

#+begin_src emacs-lisp
  (use-package cc-mode
    :ensure nil
    :general
    (:keymaps 'c-mode-map
              "C-c C-a" nil))
#+end_src

*** [[https://github.com/MaskRay/ccls][CCLS]]
:PROPERTIES:
:CUSTOM_ID: ccls
:END:

#+begin_src emacs-lisp
  (use-package ccls
    :after projectile
    :hook ((c-mode c++-mode objc-mode cuda-mode) . (lambda () (require 'ccls) (lsp)))
    :config
    (setq ccls-initialization-options '(:index (:comments 2) :completion (:detailedLabel t)))
    (defun ccls/callee () (interactive) (lsp-ui-peek-find-custom "$ccls/call" '(:callee t)))
    (defun ccls/caller () (interactive) (lsp-ui-peek-find-custom "$ccls/call"))
    (defun ccls/vars (kind) (lsp-ui-peek-find-custom "$ccls/vars" `(:kind ,kind)))
    (defun ccls/base (levels) (lsp-ui-peek-find-custom "$ccls/inheritance" `(:levels ,levels)))
    (defun ccls/derived (levels) (lsp-ui-peek-find-custom "$ccls/inheritance" `(:levels ,levels :derived t)))
    (defun ccls/member (kind) (interactive) (lsp-ui-peek-find-custom "$ccls/member" `(:kind ,kind)))

    ;; References w/ Role::Role
    (defun ccls/references-read () (interactive)
           (lsp-ui-peek-find-custom "textDocument/references"
                                    (plist-put (lsp--text-document-position-params) :role 8)))

    ;; References w/ Role::Write
    (defun ccls/references-write ()
      (interactive)
      (lsp-ui-peek-find-custom "textDocument/references"
                               (plist-put (lsp--text-document-position-params) :role 16)))

    ;; References w/ Role::Dynamic bit (macro expansions)
    (defun ccls/references-macro () (interactive)
           (lsp-ui-peek-find-custom "textDocument/references"
                                    (plist-put (lsp--text-document-position-params) :role 64)))

    ;; References w/o Role::Call bit (e.g. where functions are taken addresses)
    (defun ccls/references-not-call () (interactive)
           (lsp-ui-peek-find-custom "textDocument/references"
                                    (plist-put (lsp--text-document-position-params) :excludeRole 32)))

    ;; ccls/vars ccls/base ccls/derived ccls/members have a parameter while others are interactive.
    ;; (ccls/base 1) direct bases
    ;; (ccls/derived 1) direct derived
    ;; (ccls/member 2) => 2 (Type) => nested classes / types in a namespace
    ;; (ccls/member 3) => 3 (Func) => member functions / functions in a namespace
    ;; (ccls/member 0) => member variables / variables in a namespace
    ;; (ccls/vars 1) => field
    ;; (ccls/vars 2) => local variable
    ;; (ccls/vars 3) => field or local variable. 3 = 1 | 2
    ;; (ccls/vars 4) => parameter

    ;; References whose filenames are under this project
    (message "`ccls' loaded"))

#+end_src

** Clojure
:PROPERTIES:
:CUSTOM_ID: clojure
:END:

*** Main mode
:PROPERTIES:
:CUSTOM_ID: main-mode-10
:END:

#+begin_src emacs-lisp
  (when use-clojure
    (use-package clojure-mode
      :hook (clojure-mode . (lambda () (add-hook 'before-save-hook 'lsp-format-buffer)))
      :config (message "`clojure-mode' loaded")))
#+end_src

*** CIDER
:PROPERTIES:
:CUSTOM_ID: cider
:END:

#+begin_src emacs-lisp
  (when use-clojure
    (use-package cider
      :config (message "`cider' loaded")))
#+end_src

** Emacs-Lisp
:PROPERTIES:
:CUSTOM_ID: emacs-lisp
:END:

*** Main mode
:PROPERTIES:
:CUSTOM_ID: main-mode-11
:END:

#+begin_src emacs-lisp
  (use-package emacs-lisp-mode
    :ensure nil
    :hook (emacs-lisp-mode . semantic-mode)
    :mode-hydra
    ((:color pink :quit-key "q")
     ("Eval"
      (("b" eval-buffer "buffer")
       ("e" eval-defun "defun")
       ("r" eval-region "region"))
      "REPL"
      (("I" ielm "ielm"))
      "Doc"
      (("f" describe-function "function")
       ("v" describe-variable "variable"))))
    :config
    (message "`emacs-lisp-mode' loaded"))
#+end_src

*** [[https://github.com/Lindydancer/lisp-extra-font-lock][Lisp extra font lock]]
:PROPERTIES:
:CUSTOM_ID: lisp-extra-font-lock
:END:

#+begin_src emacs-lisp
  (use-package lisp-extra-font-lock
    :demand t
    :config
    (lisp-extra-font-lock-global-mode 1)
    (message "`lisp-extra-font-lock' loaded"))
#+end_src

*** Puni
:PROPERTIES:
:CUSTOM_ID: puni
:END:

#+begin_src emacs-lisp
  (use-package puni
    :hook ((clojure-mode emacs-lisp-mode) . puni-mode)
    :config (message "`puni' loaded")
    ;; :general
    ;; (:keymaps 'paredit-mode-map
    ;;  "C-<right>" nil
    ;;  "C-<left>" nil)
    )
#+end_src

*** Flycheck package
:PROPERTIES:
:CUSTOM_ID: flycheck-package
:END:

#+begin_src emacs-lisp
  (use-package flycheck-package
    :hook (flycheck-mode . (lambda () (flycheck-package-setup)))
    :config (message "`flycheck-package' loaded"))
#+end_src

*** [[https://github.com/emacs-elsa/Elsa][Elsa]]
:PROPERTIES:
:CUSTOM_ID: elsa
:END:

#+begin_src emacs-lisp
  (use-package elsa)

  (use-package flycheck-elsa
    :custom (flycheck-elsa-backend 'eask)
    :hook (emacs-lisp-mode . flycheck-elsa-setup))
#+end_src

*** [[https://github.com/elisp-lsp/ellsp][Ellsp]]
:PROPERTIES:
:CUSTOM_ID: ellsp
:END:

#+begin_src emacs-lisp
  (use-package msgu
    :disabled
    :ensure (msgu :type git :host github :repo "jcs-elpa/msgu"))

  (use-package ellsp
    :disabled
    :ensure (ellsp :type git :host github :repo "elisp-lsp/ellsp")
    :hook (emacs-lisp-mode . (lambda ()
                               (ellsp-register)
                               (lsp-deferred))))
#+end_src

*** [[https://github.com/Malabarba/Nameless][Nameless]]
:PROPERTIES:
:CUSTOM_ID: nameless
:END:

#+begin_src emacs-lisp
  (use-package nameless
    :hook (emacs-lisp-mode . nameless-mode)
    :custom
    (nameless-private-prefix t))
#+end_src

*** [[https://github.com/xiongtx/eros][Eros]]
:PROPERTIES:
:CUSTOM_ID: eros
:END:

#+begin_src emacs-lisp
  (use-package eros
    :hook (emacs-lisp . (lambda () (eros-mode 1))))
#+end_src

*** [[https://github.com/Wilfred/suggest.el][Suggest]]
:PROPERTIES:
:CUSTOM_ID: suggest
:END:

#+begin_src emacs-lisp
  (use-package suggest)
#+end_src

*** [[https://github.com/syohex/ipretty][Ipretty]]
:PROPERTIES:
:CUSTOM_ID: ipretty
:END:

#+begin_src emacs-lisp
  (use-package ipretty
    :general
    ("C-h C-j" 'ipretty-last-sexp)
    ("C-h C-k" 'ipretty-last-sexp-other-buffer))
#+end_src

*** [[https://github.com/emacsorphanage/macrostep][Macrostep]]
:PROPERTIES:
:CUSTOM_ID: macrostep
:END:

#+begin_src emacs-lisp
  (use-package macrostep)
#+end_src

*** [[https://github.com/Fanael/highlight-quoted][Highlight-quoted]]
:PROPERTIES:
:CUSTOM_ID: highlight-quoted
:END:

#+begin_src emacs-lisp
  (use-package highlight-quoted
    :hook (emacs-lisp-mode . highlight-quoted-mode))
#+end_src

*** [[https://github.com/daimrod/highlight-sexp][Highlight-sexp]]
:PROPERTIES:
:CUSTOM_ID: highlight-sexp
:END:

#+begin_src emacs-lisp
  (use-package highlight-sexp
    :disabled
    :ensure (highlight-sexp :type git :host github :repo "daimrod/highlight-sexp")
    :hook (emacs-lisp-mode . highlight-sexp-mode))
#+end_src

** Elm
:PROPERTIES:
:CUSTOM_ID: elm
:END:

#+begin_src emacs-lisp
  (when use-elm
    (use-package elm-mode
      :general
      (:keymaps 'elm-mode-map
                "<tab>" 'elm-indent-cycle)
      :config (message "`elm-mode' loaded"))

    (use-package haskell-mode
      :config (message "`haskell-mode' loaded")))
#+end_src

** [[https://github.com/fsharp/emacs-fsharp-mode][Fsharp]]
:PROPERTIES:
:CUSTOM_ID: fsharp
:END:

#+begin_src emacs-lisp
  (when use-fsharp
    (use-package fsharp-mode
      :init
      (add-to-list 'exec-path (concat (getenv "HOME") "/.dotnet"))
      (add-to-list 'exec-path (concat (getenv "HOME") "/.dotnet/tools"))
      (setenv "PATH"
              (concat
               (concat (getenv "HOME") "/.dotnet")
               ":"
               (concat (getenv "HOME") "/.dotnet/tools")
               ":"
               (getenv "PATH")))
      :config (message "`fsharp-mode' loaded")))
#+end_src

** Go
:PROPERTIES:
:CUSTOM_ID: go
:END:

#+begin_src emacs-lisp
  (when use-go

    (use-package go-ts-mode
      :ensure nil
      :hook (go-ts-mode . lsp-deferred))

    (use-package flycheck-golangci-lint
      :hook (go-ts-mode . flycheck-golangci-lint-setup)))
#+end_src

** [[https://github.com/Emacs-Kotlin-Mode-Maintainers/kotlin-mode][Kotlin]]
:PROPERTIES:
:CUSTOM_ID: kotlin
:END:

#+begin_src emacs-lisp
  (when use-kotlin
    (use-package kotlin-mode
      :config (message "`kotlin-mode' loaded")))
#+end_src

** Java
:PROPERTIES:
:CUSTOM_ID: java
:END:

#+begin_src emacs-lisp
  (when use-java
    (use-package lsp-java
      :hook
      (java-mode . lsp)
      (java-mode . (lambda () (abbrev-mode -1)))))
    #+end_src

** LaTeX
:PROPERTIES:
:CUSTOM_ID: latex
:END:

If you want to use it, after downloading ~auctex-latexmk~ replace ~(require tex-buf)~ with ~(require tex)~ in ~auctex-latexmk.el~.

#+begin_src emacs-lisp
  (when use-latex
    (use-package tex-site
      :ensure (auctex :pre-build
                      (("./autogen.sh")
                       ("./configure"
                        "--without-texmf-dir"
                        "--with-packagelispdir=./"
                        "--with-packagedatadir=./")
                       ("make"))
                      :build (:not elpaca--compile-info) ;; Make will take care of this step
                      :files ("*.el" "doc/*.info*" "etc" "images" "latex" "style")
                      :version (lambda (_) (require 'tex-site) AUCTeX-version))
      :mode ("\\.tex\\'" . latex-mode)
      :hook
      (LaTeX-mode . LaTeX-math-mode)
      (LaTeX-mode . TeX-PDF-mode)
      (LaTeX-mode . flycheck-mode)
      (LaTeX-mode . LaTeX-math-mode)

      :custom
      (TeX-auto-save t)
      (TeX-parse-self t)
      (TeX-master 'dwim)
      (reftex-plug-into-AUCTeX t)
      (TeX-PDF-mode t)
      (TeX-source-correlate-mode t)
      (TeX-source-correlate-method 'synctex)
      (TeX-source-correlate-start-server t)
      (TeX-electric-sub-and-superscript t)
      (TeX-view-program-selection '((output-pdf "PDF Tools")))
      (TeX-view-program-list '(("PDF Tools" TeX-pdf-tools-sync-view)))
      (TeX-source-correlate-start-server t) ;; not sure if last line is neccessary

      :config
      ;; to have the buffer refresh after compilation,
      ;; very important so that PDFView refesh itself after comilation
      (add-hook 'TeX-after-compilation-finished-functions
                #'TeX-revert-document-buffer)
      (reftex-isearch-minor-mode)
      (message "`tex-site' loaded"))

    (use-package preview
      :ensure nil
      :hook (LaTeX-mode . LaTeX-preview-setup)
      :custom
      (preview-scale 1.4)
      (preview-scale-function
       (lambda () (* (/ 10.0 (preview-document-pt)) preview-scale)))
      :config
      ;; Don't cache preamble, it creates issues with SyncTeX. Let users enable
      ;; caching if they have compilation times that long.
      (setq preview-auto-cache-preamble nil))
    ;; :general
    ;;   (:keymaps 'LaTeX-mode-map
    ;;             "p" #'preview-at-point
    ;;             "P" #'preview-clearout-at-point))

    (use-package cdlatex
      :hook
      (LaTeX-mode . cdlatex-mode)
      (org-mode . org-cdlatex-mode)
      :custom
      ;; Use \( ... \) instead of $ ... $.
      (cdlatex-use-dollar-to-ensure-math nil)
      :general
      (:keymaps 'cdlatex-mode-map
                ;; Smartparens takes care of inserting closing delimiters, and if you
                ;; don't use smartparens you probably don't want these either.
                "TAB" nil
                "$" nil
                "(" nil
                "{" nil
                "[" nil
                "|" nil
                "<" nil
                ;; AUCTeX takes care of auto-inserting {} on _^ if you want, with
                ;; `TeX-electric-sub-and-superscript'.
                "^" nil
                "_" nil
                ;; AUCTeX already provides this with `LaTeX-insert-item'.
                [(control return)] nil))

    (use-package auctex-latexmk
      :hook
      (LaTeX-mode . (lambda ()
                      (add-to-list 'TeX-command-list
                                   '("latexmk" "(run-latexmk)"
                                     TeX-run-function nil t :help "Run latexmk") t)
                      (setq TeX-command-default "latexmk")))
      :init
      (setq auctex-latexmk-inherit-TeX-PDF-mode t)
      :config
      (auctex-latexmk-setup)
      (message "`auctex-latexmk' loaded")))
#+end_src

** Ligo
:PROPERTIES:
:CUSTOM_ID: ligo
:END:

#+begin_src emacs-lisp
  (use-package ligo-mode
    :demand t
    :ensure (:type git :host codeberg :repo "mattiasdrp/ligo-mode")
    :mode
    ("\\.mligo\\'" . ligo-caml-mode)
    ("\\.jsligo\\'" . ligo-javascript-mode)
    :hook (ligo-caml-mode . (lambda ()
                              (require 'lsp-mode)
                              (ligo-setup-lsp)
                              (lsp-deferred)))
    :config
    (message "`ligo-mode' loaded"))
#+end_src

** Michelson
:PROPERTIES:
:CUSTOM_ID: michelson
:END:

#+begin_src emacs-lisp
  (when use-michelson
    (use-package deferred
      :config (message "`deferred' loaded"))

    ;; TODO: rewrite it without hardcoded paths
    (load (concat (getenv "HOME") "/dev/nl/tezos/emacs/michelson-mode.el") nil t)
    (setq michelson-client-command (concat (getenv "HOME") "/dev/nl/tezos/tezos-client"))
    (setq michelson-alphanet nil))
#+end_src

** OCaml
:PROPERTIES:
:CUSTOM_ID: ocaml
:END:

*** Useful functions
:PROPERTIES:
:CUSTOM_ID: useful-functions
:END:

#+begin_src emacs-lisp
  ;; tuareg-mode has the prettify symbols itself
  ;; (ligature-set-ligatures 'tuareg-mode '(tuareg-prettify-symbols-basic-alist))
  ;; (ligature-set-ligatures 'tuareg-mode '(tuareg-prettify-symbols-extra-alist))
  ;; harmless if `prettify-symbols-mode' isn't active
  ;; (setq tuareg-prettify-symbols-full t)
  (defun pokemacs-opam-shell-command-to-string (command)
    "Similar to shell-command-to-string, but returns nil unless the process
    returned 0, and ignores stderr (shell-command-to-string ignores return value)"
    (let* ((return-value 0)
           (return-string
            (with-output-to-string
              (setq return-value
                    (with-current-buffer standard-output
                      (process-file shell-file-name nil '(t nil) nil
                                    shell-command-switch command))))))
      (if (= return-value 0) return-string nil)))

  (defun pokemacs-load-path-opam (&rest _)
    (let ((opam-share
           (let ((reply (pokemacs-opam-shell-command-to-string "opam var share --safe")))
             (when reply (substring reply 0 -1)))))
      (message opam-share)
      (let ((path (concat opam-share "/emacs/site-lisp")))
        (message "Path is %s" path)
        path
        )
      ))

  (defun pokemacs-erase-and-fill-buffer (buffer)
    "Erase the current BUFFER and move point to beginning of buffer."
    (with-current-buffer buffer
      (let ((npoint (search-backward "**********")))
        (message "Buffer %S" buffer)
        (goto-char npoint)
        (message "Point %S" npoint)
        (set-window-point (get-buffer-window buffer) (point))
        (message "Window Point %S" (window-point (get-buffer-window buffer))))))
#+end_src

*** [[https://github.com/ocaml/tuareg][Main mode]]
:PROPERTIES:
:CUSTOM_ID: main-mode-12
:END:

#+begin_src emacs-lisp
  (when use-ocaml
    (defcustom pokemacs-ocaml-templates
      '(
        (af "assert false;" n>)
        (pp "Printf.printf \"" p "\" " p ";" n> q)
        (pe "Printf.eprintf \"" p "\" " p ";" n> q)
        (pf "Printf.fprintf " p " \"" p "\" " p ";" n> q)
        (fp "Format.printf \"" p "\" " p ";" n> q)
        (fe "Format.eprintf \"" p "\" " p ";" n> q)
        (ff "Format.fprintf " p " \"" p "\" " p ";" n> q)
        (if "if " p n> "then begin" n> p n> "end" n> "else begin" n> p n> "end" q)
        (loc "Format.eprintf \"%s@.\" __LOC__ ;" n> q))
      "Templates for OCaml used by Tempel."
      :group 'pokemacs-languages
      :type '(repeat sexp)
      :tag " OCaml Templates")

    (defcustom pokemacs-tuareg-prettify-symbols-alist
      '(
        ("sqrt" . ?√)
        ("&&" . ?⋀)        ; 'N-ARY LOGICAL AND' (U+22C0)
        ("||" . ?⋁)        ; 'N-ARY LOGICAL OR' (U+22C1)
        ("<>" . ?≠)
        ;; Some greek letters for type parameters.
        ("'a" . ?α)
        ("'b" . ?β)
        ("'c" . ?γ)
        ("'d" . ?δ)
        ("'e" . ?ε)
        ("'f" . ?φ)
        ("'i" . ?ι)
        ("'k" . ?κ)
        ("'m" . ?μ)
        ("'n" . ?ν)
        ("'o" . ?ω)
        ("'p" . ?π)
        ("'r" . ?ρ)
        ("'s" . ?σ)
        ("'t" . ?τ)
        ("'x" . ?ξ)
        ("fun" . ?λ)
        ("not" . ?￢)
        (":=" . ?⟸))
      "Alist mapping characters to a prettified symbol"
      :group 'pokemacs-appearance
      :type '(alist
              :key-type string
              :value-type integer)
      :tag "󰘧 OCaml Ligatures")

    (use-package tuareg
      :ensure-system-package
      ((ocamllsp . "opam install ocaml-lsp-server")
       (ocamlformat . "opam install ocamlformat"))
      :mode ("\\.ml\\(<.*>\\)?\\'" . tuareg-mode)
      ;; The following line can be used instead of :ensure t to load
      ;; the tuareg.el file installed with tuareg when running opam install tuareg
      ;; I'm not really sure that it's useful.
      ;; :load-path (lambda () (pokemacs-load-path-opam))
      :init
      (defun pokemacs-lsp-set-type-key ()
        "Set `C-c C-t` in `lsp-mode-map` based on major mode."
        (general-define-key
         :keymaps 'lsp-mode-map
         "C-c C-t"
         (if (derived-mode-p 'tuareg-mode)
             #'lsp-ocaml-type-enclosing
           #'lsp-describe-thing-at-point)))

      :hook
      (lsp-mode . pokemacs-lsp-set-type-key)

      :general
      (:keymaps 'tuareg-mode-map
                "C-c C-w" nil
                "C-c C-l" nil
                "C-c o w" 'ocaml-utils-dune-watch)
      :custom
      (tuareg-opam-insinuate t)
      (tuareg-electric-indent t)

      :config
      (defun pokemacs-map (l)
        (-map (lambda (x)
                (list
                 (concat "\\([^/]+\\)" (regexp-quote (car x)))
                 (concat "\\1" (regexp-quote (cdr x)))))
              l))

      (defun cons-reverse (c)
        (cons (cdr c) (car c)))

      ;; Use opam to set environment

      (tuareg-opam-update-env (tuareg-opam-current-compiler))
      (defun pokemacs-update-opam-env (&rest _)
        (when (derived-mode-p 'tuareg-mode)
          (tuareg-opam-update-env nil)))

      (defun pokemacs-update-load-path-opam (&rest _)
        (when (derived-mode-p 'tuareg-mode)
          (let ((opam-share
                 (let ((reply (pokemacs-opam-shell-command-to-string "opam var share --safe")))
                   (when reply (substring reply 0 -1)))))
            (add-to-list 'load-path (concat opam-share "/emacs/site-lisp")))))

      (if (boundp 'window-buffer-change-functions)
          (progn
            (add-hook 'window-buffer-change-functions 'pokemacs-update-opam-env)
            (add-hook 'window-buffer-change-functions 'pokemacs-update-load-path-opam))
        (progn
          (add-hook 'post-command-hook 'pokemacs-update-opam-env)
          (add-hook 'post-command-hook 'pokemacs-update-load-path-opam)))

      (general-unbind tuareg-mode-map "C-c C-a")
      (let* ((l '(
                  (".mli" . ".ml")
                  (".mli" . ".mll")
                  (".mli" . ".mly")
                  (".mli" . ".pp.ml")
                  (".mli" . "_intf.ml")
                  ("_intf.ml" . ".ml")
                  (".pp.mli" . ".ml")
                  (".pp.mli" . ".mll")
                  (".pp.mli" . ".mly")
                  (".pp.mli" . ".pp.ml")
                  (".mll" . ".ml")
                  (".mll" . ".ml")
                  (".mly" . ".ml")
                  (".eliomi" . ".eliom")))
             (rl (-map #'cons-reverse l))
             (l (pokemacs-map l))
             (rl (pokemacs-map rl)))
        (setq find-sibling-rules (append find-sibling-rules l rl)))

      (if use-ligature
          (add-hook
           'tuareg-mode-hook
           (lambda ()
             ;; Commented symbols are actually prettier with ligatures or just ugly
             (setq prettify-symbols-alist pokemacs-tuareg-prettify-symbols-alist)))
        (progn
          (setq tuareg-prettify-symbols-basic-alist nil)
          (setq tuareg-prettify-symbols-extra-alist nil)))

      (message "`tuareg' loaded"))

    (use-package ocp-indent
      ;; must be careful to always defer this, it has autoloads that adds hooks
      ;; which we do not want if the executable can't be found
      :hook (tuareg-mode . pokemacs-ocaml-init-ocp-indent-h)
      :config
      (defun pokemacs-ocaml-init-ocp-indent-h ()
        "Run `ocp-setup-indent', so long as the ocp-indent binary exists."
        (when (executable-find "ocp-indent")
          (ocp-setup-indent)))
      (message "`ocp-indent' loaded")))
#+end_src

*** Tuareg Menhir
:PROPERTIES:
:CUSTOM_ID: tuareg-menhir
:END:

Special tuareg mode when editing ~mly~ files.

#+begin_src emacs-lisp
  (when use-ocaml
    (use-package tuareg-menhir
      :ensure nil
      :mode ("\\.mly'" . tuareg-menhir-mode)
      :config (message "`tuareg-menhir' loaded")))
#+end_src

*** Dune commands
:PROPERTIES:
:CUSTOM_ID: dune-commands
:END:

#+begin_src emacs-lisp
  (when use-ocaml
    (use-package dune-minor
      :load-path "lisp/"
      :ensure nil
      :hook (tuareg-mode . dune-minor-mode)
      :config (message "`dune-minor' loaded")))
#+end_src

*** OCaml utils
:PROPERTIES:
:CUSTOM_ID: ocaml-utils
:END:

#+begin_src emacs-lisp
  (use-package ocaml-utils-mode
    ;; :ensure nil
    ;; :load-path "~/ocaml-utils-mode/"
    :ensure (ocaml-utils-mode :host codeberg :repo "mattiasdrp/ocaml-utils-mode")
    :hook (tuareg-mode . (lambda ()
                           (require 'pokemacs-layout)
                           (require 'ocaml-utils-mode)))
    :config
    (setq pokemacs-layout-layouts
          (add-to-list 'pokemacs-layout-layouts
                       '(:name "OCaml watch default layout" :layout
                               ((:windows ((column nil nil pokemacs-layout-columns)) :sides
                                          ((right (1 (magit-status-quick "*Proced*") t)
                                                  (2 ("*compilation*" "*lsp-help*" "*dune watch*") t)))))
                               :description
                               "3 vertical columns with last one being magit | (compilation, lsp-help or dune watch)")))
    (message "`ocaml-utils' loaded"))
#+end_src

** [[https://github.com/politza/pdf-tools][Pdf files]]
:PROPERTIES:
:CUSTOM_ID: pdf-files
:END:

In order to use this package you need to run ~M-x pdf-tools-install~ the first time your configuration is loaded.

#+begin_src emacs-lisp
  (use-package pdf-tools
    :mode ("\\.pdf\\'" . pdf-view-mode)
    :magic ("%PDF" . pdf-view-mode)
    :hook
    (pdf-view-mode . (lambda () (nlinum-mode 0)))
    :custom
    (pdf-view-display-size 'fit-page)
    ;; Enable hiDPI support, but at the cost of memory! See politza/pdf-tools#51
    (pdf-view-use-scaling t)
    (pdf-view-use-imagemagick nil)

    :config
    (message "`pdf-tools' loaded"))
#+end_src

*** [[https://github.com/nicolaisingh/saveplace-pdf-view][Saveplace in pdf]]
:PROPERTIES:
:CUSTOM_ID: saveplace-in-pdf
:END:

#+begin_src emacs-lisp
  (use-package saveplace-pdf-view
    :after pdf-view
    :config (message "`saveplace-pdf-view' loaded"))
#+end_src

** Python
:PROPERTIES:
:CUSTOM_ID: python
:END:

*** [[https://gitlab.com/python-mode-devs/python-mode][Main mode]]
:PROPERTIES:
:CUSTOM_ID: main-mode-13
:END:

#+begin_src emacs-lisp
  (when use-python
    (use-package python
      :ensure nil
      :hook (python-ts-mode . semantic-mode)
      :custom
      (python-indent-guess-indent-offset-verbose nil)
      :config
      ;; Remove guess indent python message
      ;; Use IPython when available or fall back to regular Python
      (cond
       ((executable-find "ipython")
        (progn
          (setopt
           python-shell-buffer-name "IPython"
           python-shell-interpreter "ipython"
           python-shell-interpreter-args "-i --simple-prompt")))
       ((executable-find "python3")
        (setopt python-shell-interpreter "python3"))
       ((executable-find "python2")
        (setopt python-shell-interpreter "python2"))
       (t
        (setopt python-shell-interpreter "python")))
      (message "`python' loaded")))
#+end_src

*** [[https://github.com/jorgenschaefer/pyvenv][Pyvenv]]
:PROPERTIES:
:CUSTOM_ID: pyvenv
:END:
Required to easily switch virtual envs via the menu bar or with ~pyvenv-workon~

Setting the ~WORKON_HOME~ environment variable points at where the envs are located.

#+begin_src emacs-lisp
  (when use-python
    (use-package pyvenv
      :hook (python-ts-mode . pyvenv-mode)
      :custom
      ;; Display virtual envs in the menu bar
      (pyvenv-menu t)
      :config
      ;; Setting work on to easily switch between environments
      (setenv "WORKON_HOME" (expand-file-name "~/miniconda3/envs/"))
      ;; Restart the python process when switching environments
      (add-hook 'pyvenv-post-activate-hooks
                (lambda () (pyvenv-restart-python)))
      (message "`pyvenv' loaded")))
#+end_src

*** [[https://github.com/emacs-lsp/lsp-pyright][Lsp pyright]]
:PROPERTIES:
:CUSTOM_ID: lsp-pyright
:END:

Language server for Python

Read the docs for the different variables set in the config.

#+begin_src emacs-lisp
  (when use-python
    (use-package lsp-pyright
      :after (python lsp-mode)
      :hook (python-ts-mode . (lambda ()
                                (require 'lsp-pyright)
                                (lsp-deferred)))
      :custom
      (lsp-clients-python-library-directories '("/usr/" "~/miniconda3/pkgs"))
      (lsp-pyright-disable-language-service nil)
      (lsp-pyright-disable-organize-imports nil)
      (lsp-pyright-auto-import-completions t)
      (lsp-pyright-use-library-code-for-types t)
      (lsp-pyright-venv-path "~/miniconda3/envs")
      :config
      (message "`lsp-pyright' loaded")))
#+end_src

** Racket
:PROPERTIES:
:CUSTOM_ID: racket
:END:

#+begin_src emacs-lisp
  (when use-racket
    (use-package ob-racket
      :hook (org-mode . (lambda () (require 'ob-racket)))
      :ensure (:type git :host github :repo "hasu/emacs-ob-racket")
      :config
      (message "`ob-racket' loaded"))

    (use-package racket-mode))
#+end_src

** [[https://github.com/reasonml-editor/reason-mode][Reason]]
:PROPERTIES:
:CUSTOM_ID: reason
:END:

Some people use this, not my responsibility.

#+begin_src emacs-lisp
  (when use-reason
    (defun shell-cmd (cmd)
      "Returns the stdout output of a shell command or nil if the command returned
     an error"
      (car (ignore-errors (apply 'process-lines (split-string cmd)))))

    (defun reason-cmd-where (cmd)
      (let ((where (shell-cmd cmd)))
        (if (not (string-equal "unknown flag ----where" where))
            where)))

    (let* ((refmt-bin (or (reason-cmd-where "refmt ----where")
                          (shell-cmd "which refmt")
                          (shell-cmd "which bsrefmt")))
           (merlin-bin (or (reason-cmd-where "ocamlmerlin ----where")
                           (shell-cmd "which ocamlmerlin")))
           (merlin-base-dir (when merlin-bin
                              (replace-regexp-in-string "bin/ocamlmerlin$" "" merlin-bin))))
      ;; Add merlin.el to the emacs load path and tell emacs where to find ocamlmerlin
      (when merlin-bin
        (add-to-list 'load-path (concat merlin-base-dir "share/emacs/site-lisp/"))
        (setq merlin-command merlin-bin))

      (when refmt-bin
        (setq refmt-command refmt-bin)))

    (use-package reason-mode
      :hook (reason-mode . (lambda ()
                             (add-hook 'before-save-hook 'refmt-before-save)
                             (merlin-mode)))
      :config (message "`reason-mode' loaded")))
#+end_src

** RST
:PROPERTIES:
:CUSTOM_ID: rst
:END:

#+begin_src emacs-lisp
  (use-package rst-mode
    :ensure nil
    :hook (rst-mode . auto-fill-mode))
#+end_src

** Ruby
:PROPERTIES:
:CUSTOM_ID: ruby
:END:

#+begin_src emacs-lisp
  (when use-ruby
    (use-package enh-ruby-mode
      :mode (("Appraisals\\'" . enh-ruby-mode)
             ("\\(Rake\\|Thor\\|Guard\\|Gem\\|Cap\\|Vagrant\\|Berks\\|Pod\\|Puppet\\)file\\'" . enh-ruby-mode)
             ("\\.\\(rb\\|rabl\\|ru\\|builder\\|rake\\|thor\\|gemspec\\|jbuilder\\|pryrc\\)\\'" . enh-ruby-mode))
      :after lsp-mode
      :ensure-system-package (solargraph . "gem install --user-install solargraph")
      :hook (enh-ruby-mode . lsp-deferred)
      :interpreter "ruby"
      :custom
      (enh-ruby-deep-indent-paren nil)
      (enh-ruby-hanging-paren-deep-indent-level 2)
      (ruby-insert-encoding-magic-comment nil "Not needed in Ruby 2"))

    (use-package rbenv)

    (use-package inf-ruby)

    (use-package seeing-is-believing
      :hook (enh-ruby-mode . seeing-is-believing)
      :general
      (:keymaps 'enh-ruby-mode-map
                "C-c s" 'seeing-is-believing-run
                "C-c c" 'seeing-is-believing-clear)))
#+end_src

** Rust
:PROPERTIES:
:CUSTOM_ID: rust
:END:

[[https://github.com/brotzeit/rustic][Rustic]]:

#+begin_src emacs-lisp
  (when use-rust

    (use-package ob-rust
      :hook (org-mode . (lambda () (require 'ob-rust)))
      :config
      (message "`ob-rust' loaded"))

    (use-package rustic
      :ensure (:repo "emacs-rustic/rustic")
      :ensure-system-package
      ((taplo . "cargo install taplo-cli --features lsp")
       (rustfmt . "cargo install rustfmt"))
      :hook
      (rustic-mode . pokemacs-set-rustic-compilation-mode)
      :general
      (:keymaps 'rustic-mode-map
                "C-c s" 'lsp-rust-analyzer-status
                "C-M-;" 'pokemacs-rust-doc-comment-dwim-following
                "C-M-," 'pokemacs-rust-doc-comment-dwim-enclosing)
      :init
      (setq auto-mode-alist (delete '("\\.rs\\'" . rust-mode) auto-mode-alist))
      (setq auto-mode-alist (delete '("\\.rs\\'" . rust-ts-mode) auto-mode-alist))
      (setopt rust-mode-treesitter-derive t)

      (defun pokemacs--dir-contains-cargo-toml-p (dir)
        "Return t if the project root contains a Cargo.toml file."
        (file-exists-p (expand-file-name "Cargo.toml" dir)))

      (defun pokemacs--find-cargo-tomls (root-dir)
        "Find all Cargo.toml files using Projectile's project files."
        (let* ((project-root (if (string-equal root-dir "Current project")
                                 (projectile-project-root)
                               (projectile-project-root)))
               (all-files (projectile-project-files project-root))
               (cargo-files
                (seq-filter
                 (lambda (file) (string-suffix-p "Cargo.toml" file))
                 all-files))
               (absolute-cargo-files
                (mapcar (lambda (rel-path)
                          (expand-file-name rel-path project-root)) cargo-files)))
          (apply #'vector absolute-cargo-files)))

      (defun pokemacs--workspace-folders-alread-exist (dir)
        (let* ((folders (lsp-session-folders (lsp-session)))
               (-compare-fn #'string=))
          (-contains-p folders (directory-file-name dir))))

      (defun pokemacs--setup-rust-lsp (&rest _)
        "Add a new workspace folder to lsp if a Cargo.toml file can't be find at the project root.

  Return the folder in which rust-analyzer will be started."
        (when (and
               (derived-mode-p 'rust-mode)
               (not (pokemacs--dir-contains-cargo-toml-p (projectile-project-root))))
          (setq-local rustic-compile-directory-method #'rustic-buffer-workspace)
          (let* ((project-dir (file-truename (projectile-project-root)))
                 (current-dir (file-truename  default-directory))
                 (path (file-relative-name current-dir project-dir))
                 (cargo-dirs nil)
                 (existing-folder nil))
            (while (and
                    (and (stringp path) (not (string= "./" path)))
                    (not existing-folder))
              (let* ((dir (file-name-concat project-dir path)))
                (if (pokemacs--workspace-folders-alread-exist dir)
                    (setq existing-folder dir)
                  (when (pokemacs--dir-contains-cargo-toml-p dir)
                    (push path cargo-dirs)))
                (setq path (file-name-parent-directory path))))
            (or existing-folder
                (let* ((chosen-dir (completing-read "Which root do you want to load: "
                                                    cargo-dirs nil nil nil t)))
                  (lsp-workspace-folders-add (file-name-concat project-dir chosen-dir))
                  chosen-dir)))))

      (advice-add #'lsp :before #'pokemacs--setup-rust-lsp)

      :custom
      (rust-prettify-symbols-alist nil)
      ;; Allign to `.`
      (rustic-indent-method-chain t)
      ;; Let apheleia handle reformatting
      (rustic-babel-format-src-block nil)
      (rustic-format-trigger nil)

      :init
      (defun pokemacs-rust-doc-comment-dwim (c)
        "Comment or uncomment the current line or text selection."
        (interactive)

        ;; If there's no text selection, comment or uncomment the line
        ;; depending whether the WHOLE line is a comment. If there is a text
        ;; selection, using the first line to determine whether to
        ;; comment/uncomment.
        (let (p1 p2)
          (if (use-region-p)
              (save-excursion
                (setq p1 (region-beginning) p2 (region-end))
                (goto-char p1)
                (if (wholeLineIsCmt-p c)
                    (pokemacs-uncomment-region p1 p2 c)
                  (pokemacs-comment-region p1 p2 c)
                  ))
            (progn
              (if (wholeLineIsCmt-p c)
                  (pokemacs-uncomment-current-line c)
                (pokemacs-comment-current-line c)
                )))))

      (defun pokemacs-wholeLineIsCmt-p (c)
        (save-excursion
          (beginning-of-line 1)
          (looking-at (concat "[ \t]*//" c))
          ))

      (defun pokemacs-comment-current-line (c)
        (interactive)
        (beginning-of-line 1)
        (insert (concat "//" c))
        )

      (defun pokemacs-uncomment-current-line (c)
        "Remove “//c” (if any) in the beginning of current line."
        (interactive)
        (when (wholeLineIsCmt-p c)
          (beginning-of-line 1)
          (search-forward (concat "//" c))
          (delete-backward-char 4)
          ))

      (defun pokemacs-comment-region (p1 p2 c)
        "Add “//c” to the beginning of each line of selected text."
        (interactive "r")
        (let ((deactivate-mark nil))
          (save-excursion
            (goto-char p2)
            (while (>= (point) p1)
              (pokemacs-comment-current-line c)
              (previous-line)
              ))))

      (defun pokemacs-uncomment-region (p1 p2 c)
        "Remove “//c” (if any) in the beginning of each line of selected text."
        (interactive "r")
        (let ((deactivate-mark nil))
          (save-excursion
            (goto-char p2)
            (while (>= (point) p1)
              (pokemacs-uncomment-current-line c)
              (previous-line) )) ))

      (defun pokemacs-rust-doc-comment-dwim-following ()
        (interactive)
        (pokemacs-rust-doc-comment-dwim "/ "))

      (defun pokemacs-rust-doc-comment-dwim-enclosing ()
        (interactive)
        (pokemacs-rust-doc-comment-dwim "! "))

      :config
      (define-derived-mode pokemacs-rustic-compilation-mode rustic-compilation-mode "compilation"
        "A wrapper for `rustic-compilation-mode'.")
      (defun pokemacs-function-rustic-compilation-mode (buf _str)
        (with-current-buffer buf
          (pokemacs-rustic-compilation-mode)
          (compilation-auto-jump buf (match-beginning 0))))

      (defun pokemacs-set-rustic-compilation-mode ()
        (add-to-list 'compilation-finish-functions 'pokemacs-function-rustic-compilation-mode))
      ;; uncomment for less flashiness
      ;; (setq lsp-eldoc-hook nil)
      ;; (setq lsp-enable-symbol-highlighting nil)
      ;; (setq lsp-signature-auto-activate nil)
      ;; (defun my/rust-mode-outline-regexp-setup ()
      ;;   (setq-local outline-regexp "///[;]\\{1,8\\}[^ \t]"))
      (message "`rustic' loaded")))
#+end_src

*** CSV


#+begin_src emacs-lisp
  (use-package csv-mode
    :demand t
    :ensure t)
#+end_src


** SICP
:PROPERTIES:
:CUSTOM_ID: sicp
:END:

#+begin_src emacs-lisp
  (when use-sicp
    (use-package sicp))
#+end_src

** Web modes
:PROPERTIES:
:CUSTOM_ID: web-modes
:END:

*** [[https://github.com/fxbois/web-mode][Main mode]]
:PROPERTIES:
:CUSTOM_ID: main-mode-14
:END:

#+begin_src emacs-lisp
  (when use-web
    (use-package web-mode
      :mode "\\.php\\'"
      :config (message "`web-mode' loaded")))
#+end_src

*** CSS mode
:PROPERTIES:
:CUSTOM_ID: css-mode
:END:

#+begin_src emacs-lisp
  (when use-web
    (use-package css-mode
      :ensure nil
      :mode "\\.css\\'"
      :config (message "`css-mode' loaded")))
#+end_src

*** Simple HTTPD
:PROPERTIES:
:CUSTOM_ID: simple-httpd
:END:

#+begin_src emacs-lisp
  (use-package simple-httpd
    :ensure nil
    :config (message "`simple-httpd' loaded"))
#+end_src

*** Beautify
:PROPERTIES:
:CUSTOM_ID: beautify
:END:

#+begin_src emacs-lisp
  (use-package web-beautify
    :ensure (web-beautify :repo "https://github.com/yasuyk/web-beautify"))
#+end_src

** Zig
:PROPERTIES:
:CUSTOM_ID: zig
:END:

Zig expects to find the binary for ~zig~ and ~zls~ to be able to run LSP. Customize ~lsp-zig-zig-exe-path~ and ~lsp-zig-zls-executable~.

#+begin_src emacs-lisp
  (when use-zig
    (use-package zig-mode
      :custom
      (lsp-zig-zig-exe-path (file-truename "~/.zig/zig/zig"))
      (lsp-zig-zls-executable (file-truename "~/.zig/zls/zig-out/bin/zls"))
      (zig-format-on-save nil))

    (use-package zig-ts-mode
      :ensure (:type git :host codeberg :repo "meow_king/zig-ts-mode")
      :init
      (add-to-list 'auto-mode-alist '("\\.zig\\'" . zig-ts-mode))
      :config
      (require 'zig-mode)
      (set-keymap-parent zig-ts-mode-map zig-mode-map)))
#+end_src

* Shitty wizards
:PROPERTIES:
:CUSTOM_ID: shitty-wizards
:END:

Company policies sometimes force you to use LLM. I wish they didn't but they do and you need butter in your épinards. So here it is...

#+begin_src emacs-lisp
  (defcustom use-copilot nil
    "If non-nil, uses the copilot packages."
    :group 'pokemacs-packages
    :type 'boolean
    :tag " Copilot")

  (defcustom use-eca nil
    "If non-nil, uses the ECA (editor code assistants) packages."
    :group 'pokemacs-packages
    :type 'boolean
    :tag "󰵰 ECA")
#+end_src

** Copilot
:PROPERTIES:
:CUSTOM_ID: copilot
:END:

#+begin_src emacs-lisp
    (when use-copilot
      (use-package copilot
        :ensure (copilot :host github :repo "copilot-emacs/copilot.el" :files ("*.el"))
        :init (copilot-mode)
        :hook (prog-mode . copilot-mode)
        :general
        (:keymaps 'copilot-completion-map
                  "<tab>" 'copilot-accept-completion
                  "TAB" 'copilot-accept-completion
                  "C-TAB" 'copilot-accept-completion-by-word
                  "C-<tab>" 'copilot-accept-completion-by-word
                  "C-n" 'copilot-next-completion
                  "C-p" 'copilot-previous-completion)
        (add-to-list 'copilot-indentation-alist '(prog-mode 2))
        (add-to-list 'copilot-indentation-alist '(org-mode 2))
        (add-to-list 'copilot-indentation-alist '(text-mode 2))
        (add-to-list 'copilot-indentation-alist '(closure-mode 2))
        (add-to-list 'copilot-indentation-alist '(emacs-lisp-mode 2))))
#+end_src

** Copilot-chat
:PROPERTIES:
:CUSTOM_ID: copilot-chat
:END:

#+begin_src emacs-lisp
  (when use-copilot
    (use-package copilot-chat))

#+end_src

** [[https://github.com/editor-code-assistant/eca-emacs][ECA]]
:PROPERTIES:
:CUSTOM_ID: eca
:END:

#+begin_src emacs-lisp
  (when use-eca
    (use-package eca
      :ensure (:host github :repo "editor-code-assistant/eca-emacs"))

    (use-package eca-chat-mode
      :ensure nil
      :hook (eca-chat-mode . (lambda () (setq-local completion-at-point-functions '(eca-chat-completion-at-point))))))
#+end_src

* End
:PROPERTIES:
:CUSTOM_ID: end
:END:

After everything has been done, load [[file:post-init.el][post-init.el]] to override some keybindings and close [[file:init.el][init.el]].

#+begin_src emacs-lisp
  (add-hook 'elpaca-after-init-hook
            (lambda ()
              (setq post-init-file (expand-file-name "post-init.el" user-emacs-directory))
              (load post-init-file)))

  (message "`init' file loaded")
  ;;;; Footer
  (message "Number of gcs: %d" gcs-done)
  ;; End:
  (provide 'init)

  ;;; init.el ends here
#+end_src