actual final changes and get rid of junk in lisp dir

actually works fine

5 files changed, 0 insertions, 1088 deletions

diff --git a/.config/emacs/lisp/expand-region/cc-mode-expansions.el b/.config/emacs/lisp/expand-region/cc-mode-expansions.el
deleted file mode 100644
index 126b7f1..0000000
--- a/.config/emacs/lisp/expand-region/cc-mode-expansions.el
+++ /dev/null
@@ -1,186 +0,0 @@
-;;; cc-mode-expansions.el --- C-specific expansions for expand-region  -*- lexical-binding: t; -*-
-
-;; Copyright (C) 2012-2023  Free Software Foundation, Inc
-
-;; Author: François Févotte
-;; Based on js-mode-expansions by: Magnar Sveen <magnars@gmail.com>
-;; Keywords: marking region
-
-;; This program is free software; you can redistribute it and/or modify
-;; it under the terms of the GNU General Public License as published by
-;; the Free Software Foundation, either version 3 of the License, or
-;; (at your option) any later version.
-
-;; This program is distributed in the hope that it will be useful,
-;; but WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-;; GNU General Public License for more details.
-
-;; You should have received a copy of the GNU General Public License
-;; along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-;;; Commentary:
-;;
-;; Extra expansions for C-like modes that I've found useful so far:
-;;
-;; er/c-mark-statement
-;;     Captures simple and more complex statements.
-;;
-;; er/c-mark-fully-qualified-name
-;;     Captures identifiers composed of several '::'-separated parts.
-;;
-;; er/c-mark-function-call[-1|-2]
-;;     Captures an identifier followed by a '()'-enclosed block.
-;;
-;; er/c-mark-statement-block[-1|-2]
-;;     Captures a statement followed by a '{}'-enclosed block.
-;;     This matches function definitions and if/for/... constructs.
-;;
-;; er/c-mark-vector-access[-1|-2]
-;;     Captures an identifier followed by a '[]'-enclosed block.
-;;
-;; Feel free to contribute any other expansions for C at
-;;
-;;     https://github.com/magnars/expand-region.el
-
-;;; Code:
-
-(require 'expand-region-core)
-(require 'er-basic-expansions)
-(require 'cc-cmds)
-
-(defun er/c-mark-statement ()
-  "Mark the current C statement.
-
-This function tries to ensure that pair-delimited substring are
-either fully inside or fully outside the statement."
-  (interactive)
-  (unless (use-region-p)
-    (set-mark (point)))
-
-  (if (< (point) (mark))
-      (exchange-point-and-mark))
-
-  ;; Contract the region a bit to make the
-  ;; er/c-mark-statement function idempotent
-  (when (>= (- (point) (mark)) 2)
-    (exchange-point-and-mark)
-    (forward-char)
-    (exchange-point-and-mark)
-    (backward-char))
-
-  (let (beg end)
-    ;; Determine boundaries of the outside-pairs region
-    (save-mark-and-excursion
-      (c-end-of-statement)
-      (er/mark-outside-pairs)
-      (setq beg (point)
-            end (mark)))
-
-    ;; Determine boundaries of the statement as given
-    ;; by c-beginning-of-statement/c-end-of-statement
-    (c-end-of-statement)
-    (exchange-point-and-mark)
-    (c-end-of-statement)(c-beginning-of-statement 1)
-
-    ;; If the two regions overlap, expand the region
-    (cond ((and (<= (point) beg)
-                (<  (mark)  end))
-           (set-mark end))
-          ((and (>  (point) beg)
-                (>= (mark)  end))
-           (goto-char beg)
-           (c-end-of-statement)
-           (c-beginning-of-statement 1)))))
-
-(defun er/c-mark-fully-qualified-name ()
-  "Mark the current C++ fully qualified identifier.
-
-This function captures identifiers composed of multiple
-'::'-separated parts."
-  (interactive)
-  (er/mark-symbol)
-  (when (use-region-p)
-    (when (> (point) (mark))
-      (exchange-point-and-mark))
-    (while (er/looking-back-exact "::")
-      (backward-char 2)
-      (skip-syntax-backward "_w"))
-    (exchange-point-and-mark)
-    (while (looking-at "::")
-      (forward-char 2)
-      (skip-syntax-forward "_w"))
-    (exchange-point-and-mark)))
-
-(defmacro er/c-define-construct (name mark-first-part open-brace doc)
-  (let ((docstring (make-symbol "docstring-tmp")))
-    (setq docstring
-          (concat
-           doc "\n\n"
-           "This function tries to mark a region consisting of two parts:\n"
-           (format " - the first part is marked using `%s'\n" (symbol-name mark-first-part))
-           (format " - the second part is a block beginning with %S\n\n" open-brace)))
-    `(progn
-       (defun ,(intern (concat (symbol-name name) "-1")) ()
-         ,(concat docstring
-                  "This function assumes that point is in the first part and the\n"
-                  "region is active.\n\n"
-                  (format "See also `%s'." (concat (symbol-name name) "-2")))
-         (interactive)
-         (when (use-region-p)
-           (,mark-first-part)
-           (exchange-point-and-mark)
-           (let ((oldpos (point)))
-             (skip-syntax-forward " ")
-             (if (looking-at ,open-brace)
-                 (progn (forward-sexp)
-                        (exchange-point-and-mark))
-               (goto-char oldpos)))))
-       (defun ,(intern (concat (symbol-name name) "-2")) ()
-         ,(concat docstring
-                  "This function assumes that the block constituting the second part\n"
-                  "is already marked and active.\n\n"
-                  (format "See also `%s'." (concat (symbol-name name) "-1")))
-         (interactive)
-         (when (use-region-p)
-           (when (> (point) (mark))
-             (exchange-point-and-mark))
-           (when (looking-at ,open-brace)
-             (let ((beg (point))
-                   (end (progn (forward-sexp 1)
-                               (point))))
-               (goto-char beg)
-               (skip-syntax-backward " ")
-               (backward-char)
-               (deactivate-mark)
-               (,mark-first-part)
-               (set-mark end))))))))
-
-(er/c-define-construct er/c-mark-function-call er/c-mark-fully-qualified-name "("
-                       "Mark the current function call.")
-(er/c-define-construct er/c-mark-statement-block er/c-mark-statement "{"
-                       "Mark the current block construct (like if, for, etc.)")
-(er/c-define-construct er/c-mark-vector-access er/c-mark-fully-qualified-name "\\["
-                       "Mark the current vector access.")
-
-(defun er/add-cc-mode-expansions ()
-  "Adds expansions for buffers in c-mode."
-  (set (make-local-variable 'er/try-expand-list)
-       (append er/try-expand-list
-               '(er/c-mark-statement
-                 er/c-mark-fully-qualified-name
-                 er/c-mark-function-call-1   er/c-mark-function-call-2
-                 er/c-mark-statement-block-1 er/c-mark-statement-block-2
-                 er/c-mark-vector-access-1   er/c-mark-vector-access-2))))
-
-(er/enable-mode-expansions 'c-mode #'er/add-cc-mode-expansions)
-(er/enable-mode-expansions 'c++-mode #'er/add-cc-mode-expansions)
-(er/enable-mode-expansions 'objc-mode #'er/add-cc-mode-expansions)
-(er/enable-mode-expansions 'java-mode #'er/add-cc-mode-expansions)
-(er/enable-mode-expansions 'idl-mode #'er/add-cc-mode-expansions)
-(er/enable-mode-expansions 'pike-mode #'er/add-cc-mode-expansions)
-(er/enable-mode-expansions 'awk-mode #'er/add-cc-mode-expansions)
-
-(provide 'cc-mode-expansions)
-
-;; cc-mode-expansions.el ends here
diff --git a/.config/emacs/lisp/expand-region/er-basic-expansions.el b/.config/emacs/lisp/expand-region/er-basic-expansions.el
deleted file mode 100644
index 08cdc56..0000000
--- a/.config/emacs/lisp/expand-region/er-basic-expansions.el
+++ /dev/null
@@ -1,267 +0,0 @@
-;;; er-basic-expansions.el --- Words, symbols, strings, et al  -*- lexical-binding: t; -*-
-
-;; Copyright (C) 2011-2023  Free Software Foundation, Inc
-
-;; Author: Magnar Sveen <magnars@gmail.com>
-;; Keywords: marking region
-
-;; This program is free software; you can redistribute it and/or modify
-;; it under the terms of the GNU General Public License as published by
-;; the Free Software Foundation, either version 3 of the License, or
-;; (at your option) any later version.
-
-;; This program is distributed in the hope that it will be useful,
-;; but WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-;; GNU General Public License for more details.
-
-;; You should have received a copy of the GNU General Public License
-;; along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-;;; Commentary:
-
-;; Expansions that are useful in any major mode.
-
-;;; Code:
-
-(require 'expand-region-core)
-
-(defun er/mark-word ()
-  "Mark the entire word around or in front of point."
-  (interactive)
-  (let ((word-regexp "\\sw"))
-    (when (or (looking-at word-regexp)
-              (er/looking-back-on-line word-regexp))
-      (skip-syntax-forward "w")
-      (set-mark (point))
-      (skip-syntax-backward "w"))))
-
-(defun er/mark-symbol ()
-  "Mark the entire symbol around or in front of point."
-  (interactive)
-  (let ((symbol-regexp "\\s_\\|\\sw"))
-    (when (or (looking-at symbol-regexp)
-              (er/looking-back-on-line symbol-regexp))
-      (skip-syntax-forward "_w")
-      (set-mark (point))
-      (skip-syntax-backward "_w"))))
-
-(defun er/mark-symbol-with-prefix ()
-  "Mark the entire symbol around or in front of point, including prefix."
-  (interactive)
-  (let ((symbol-regexp "\\s_\\|\\sw")
-        (prefix-regexp "\\s'"))
-    (when (or (looking-at prefix-regexp)
-              (looking-at symbol-regexp)
-              (er/looking-back-on-line symbol-regexp))
-      (skip-syntax-forward "'")
-      (skip-syntax-forward "_w")
-      (set-mark (point))
-      (skip-syntax-backward "_w")
-      (skip-syntax-backward "'"))))
-
-;; Mark method call
-
-(defun er/mark-next-accessor ()
-  "Presumes that current symbol is already marked, skips over one
-period and marks next symbol."
-  (interactive)
-  (when (use-region-p)
-    (when (< (point) (mark))
-      (exchange-point-and-mark))
-    ;; (let ((symbol-regexp "\\s_\\|\\sw"))
-      (when (looking-at "\\.")
-        (forward-char 1)
-        (skip-syntax-forward "_w")
-        (exchange-point-and-mark)))) ;; )
-
-(defun er/mark-method-call ()
-  "Mark the current symbol (including dots) and then paren to closing paren."
-  (interactive)
-  (let ((symbol-regexp "\\(\\s_\\|\\sw\\|\\.\\)+"))
-    (when (or (looking-at symbol-regexp)
-              (er/looking-back-on-line symbol-regexp))
-      (skip-syntax-backward "_w.")
-      (set-mark (point))
-      (when (looking-at symbol-regexp)
-        (goto-char (match-end 0)))
-      (if (looking-at "(")
-          (forward-list))
-      (exchange-point-and-mark))))
-
-;; Comments
-
-(defun er--point-is-in-comment-p ()
-  "t if point is in comment, otherwise nil"
-  (or (nth 4 (syntax-ppss))
-      (memq (get-text-property (point) 'face) '(font-lock-comment-face font-lock-comment-delimiter-face))))
-
-(defun er/mark-comment ()
-  "Mark the entire comment around point."
-  (interactive)
-  (when (er--point-is-in-comment-p)
-    (let ((p (point)))
-      (while (and (er--point-is-in-comment-p) (not (eobp)))
-        (forward-char 1))
-      (skip-chars-backward "\n\r")
-      (set-mark (point))
-      (goto-char p)
-      (while (er--point-is-in-comment-p)
-        (forward-char -1))
-      (forward-char 1))))
-
-;; Quotes
-
-(defun er--current-quotes-char ()
-  "The char that is the current quote delimiter"
-  (nth 3 (syntax-ppss)))
-
-(defalias 'er--point-inside-string-p #'er--current-quotes-char)
-
-(defun er--move-point-forward-out-of-string ()
-  "Move point forward until it exits the current quoted string."
-  (er--move-point-backward-out-of-string)
-  (forward-sexp))
-
-(defun er--move-point-backward-out-of-string ()
-  "Move point backward until it exits the current quoted string."
-  (goto-char (nth 8 (syntax-ppss))))
-
-(defun er/mark-inside-quotes ()
-  "Mark the inside of the current string, not including the quotation marks."
-  (interactive)
-  (when (er--point-inside-string-p)
-    (er--move-point-backward-out-of-string)
-    (forward-char)
-    (set-mark (point))
-    (er--move-point-forward-out-of-string)
-    (backward-char)
-    (exchange-point-and-mark)))
-
-(defun er/mark-outside-quotes ()
-  "Mark the current string, including the quotation marks."
-  (interactive)
-  (if (er--point-inside-string-p)
-      (er--move-point-backward-out-of-string)
-    (when (and (not (use-region-p))
-               (er/looking-back-on-line "\\s\""))
-      (backward-char)
-      (er--move-point-backward-out-of-string)))
-  (when (looking-at "\\s\"")
-    (set-mark (point))
-    (forward-char)
-    (er--move-point-forward-out-of-string)
-    (exchange-point-and-mark)))
-
-;; Pairs - ie [] () {} etc
-
-(defun er--point-inside-pairs-p ()
-  "Is point inside any pairs?"
-  (> (car (syntax-ppss)) 0))
-
-(defun er/mark-inside-pairs ()
-  "Mark inside pairs (as defined by the mode), not including the pairs."
-  (interactive)
-  (when (er--point-inside-pairs-p)
-    (goto-char (nth 1 (syntax-ppss)))
-    (set-mark (save-excursion
-                (forward-char 1)
-                (skip-chars-forward er--space-str)
-                (point)))
-    (forward-list)
-    (backward-char)
-    (skip-chars-backward er--space-str)
-    (exchange-point-and-mark)))
-
-(defun er--looking-at-pair ()
-  "Is point looking at an opening pair char?"
-  (looking-at "\\s("))
-
-(defun er--looking-at-marked-pair ()
-  "Is point looking at a pair that is entirely marked?"
-  (and (er--looking-at-pair)
-       (use-region-p)
-       (>= (mark)
-           (save-excursion
-             (forward-list)
-             (point)))))
-
-(defun er/mark-outside-pairs ()
-  "Mark pairs (as defined by the mode), including the pair chars."
-  (interactive)
-  (if (and (er/looking-back-on-line "\\s)+\\=")
-           (not (er--looking-at-pair)))
-      (ignore-errors (backward-list 1))
-    (skip-chars-forward er--space-str))
-  (when (and (er--point-inside-pairs-p)
-             (or (not (er--looking-at-pair))
-                 (er--looking-at-marked-pair)))
-    (goto-char (nth 1 (syntax-ppss))))
-  (when (er--looking-at-pair)
-    (set-mark (point))
-    (forward-list)
-    (exchange-point-and-mark)))
-
-(require 'thingatpt)
-
-(defun er/mark-url ()
-  (interactive)
-  (end-of-thing 'url)
-  (set-mark (point))
-  (beginning-of-thing 'url))
-
-(defun er/mark-email ()
-  (interactive)
-  (end-of-thing 'email)
-  (set-mark (point))
-  (beginning-of-thing 'email))
-
-(defun er/mark-defun ()
-  "Mark defun around or in front of point."
-  (interactive)
-  (end-of-defun)
-  (skip-chars-backward er--space-str)
-  (set-mark (point))
-  (beginning-of-defun)
-  (skip-chars-forward er--space-str))
-
-;; Methods to try expanding to
-(setq er/try-expand-list
-      (append '(er/mark-word
-                er/mark-symbol
-                er/mark-symbol-with-prefix
-                er/mark-next-accessor
-                er/mark-method-call
-                er/mark-inside-quotes
-                er/mark-outside-quotes
-                er/mark-inside-pairs
-                er/mark-outside-pairs
-                er/mark-comment
-                er/mark-url
-                er/mark-email
-                er/mark-defun)
-              er/try-expand-list))
-
-(when (and (>= emacs-major-version 29)
-           (treesit-available-p))
-  (defun er/mark-ts-node ()
-    "Mark tree sitter node around or after point."
-    (interactive)
-    (when (treesit-language-at (point))
-      (let* ((node (if (use-region-p)
-                       (treesit-node-on (region-beginning) (region-end))
-                     (treesit-node-at (point))))
-             (node-start (treesit-node-start node))
-             (node-end (treesit-node-end node)))
-        ;; when the node fits the region exactly, try its parent node instead
-        (when (and (= (region-beginning) node-start)
-                   (= (region-end) node-end))
-          (when-let ((node (treesit-node-parent node)))
-            (setq node-start (treesit-node-start node)
-                  node-end (treesit-node-end node))))
-        (goto-char node-start)
-        (set-mark node-end))))
-  (setq er/try-expand-list (append er/try-expand-list '(er/mark-ts-node))))
-
-(provide 'er-basic-expansions)
-;;; er-basic-expansions.el ends here
diff --git a/.config/emacs/lisp/expand-region/expand-region-core.el b/.config/emacs/lisp/expand-region/expand-region-core.el
deleted file mode 100644
index c239fd1..0000000
--- a/.config/emacs/lisp/expand-region/expand-region-core.el
+++ /dev/null
@@ -1,322 +0,0 @@
-;;; expand-region-core.el --- Increase selected region by semantic units.  -*- lexical-binding: t; -*-
-
-;; Copyright (C) 2011-2023  Free Software Foundation, Inc
-
-;; Author: Magnar Sveen <magnars@gmail.com>
-;; Keywords: marking region
-
-;; This program is free software; you can redistribute it and/or modify
-;; it under the terms of the GNU General Public License as published by
-;; the Free Software Foundation, either version 3 of the License, or
-;; (at your option) any later version.
-
-;; This program is distributed in the hope that it will be useful,
-;; but WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-;; GNU General Public License for more details.
-
-;; You should have received a copy of the GNU General Public License
-;; along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-;;; Commentary:
-
-;; The core functionality of expand-region.
-
-;; See README.md
-
-;;; Code:
-
-(require 'expand-region-custom)
-(declare-function er/expand-region "expand-region")
-
-(defvar er/history '()
-  "A history of start and end points so we can contract after expanding.")
-
-;; history is always local to a single buffer
-(make-variable-buffer-local 'er/history)
-
-(defvar er--space-str " \t\n")
-(defvar er--blank-list (append er--space-str nil))
-
-(defvar er--show-expansion-message nil)
-
-(defvar er/try-expand-list nil
-  "A list of functions that are tried when expanding.")
-
-(defvar er/save-mode-excursion nil
-  "A function to save excursion state when expanding.")
-
-(defsubst er--first-invocation ()
-  "t if this is the first invocation of `er/expand-region' or `er/contract-region'."
-  (not (memq last-command '(er/expand-region er/contract-region))))
-
-(defun er--prepare-expanding ()
-  (when (and (er--first-invocation)
-             (not (use-region-p)))
-    (push-mark nil t)  ;; one for keeping starting position
-    (push-mark nil t)) ;; one for replace by set-mark in expansions
-
-  (when (not transient-mark-mode)
-    (setq-local transient-mark-mode (cons 'only transient-mark-mode))))
-
-(defun er--copy-region-to-register ()
-  (when (and (stringp expand-region-autocopy-register)
-             (> (length expand-region-autocopy-register) 0))
-    (set-register (aref expand-region-autocopy-register 0)
-                  (filter-buffer-substring (region-beginning) (region-end)))))
-
-;; save-mark-and-excursion in Emacs 25 works like save-excursion did before
-(eval-when-compile
-  (when (< emacs-major-version 25)
-    (defmacro save-mark-and-excursion (&rest body)
-      `(save-excursion ,@body))))
-
-(defmacro er--save-excursion (&rest body)
-  `(let ((action (lambda ()
-                   (save-mark-and-excursion ,@body))))
-     (if er/save-mode-excursion
-         (funcall er/save-mode-excursion action)
-       (funcall action))))
-
-(defun er--expand-region-1 ()
-  "Increase selected region by semantic units.
-Basically it runs all the mark-functions in `er/try-expand-list'
-and chooses the one that increases the size of the region while
-moving point or mark as little as possible."
-  (let* ((p1 (point))
-         (p2 (if (use-region-p) (mark) (point)))
-         (start (min p1 p2))
-         (end (max p1 p2))
-         (try-list er/try-expand-list)
-         (best-start (point-min))
-         (best-end (point-max))
-         ;; (set-mark-default-inactive nil)
-         )
-
-    ;; add hook to clear history on buffer changes
-    (unless er/history
-      (add-hook 'after-change-functions #'er/clear-history t t))
-
-    ;; remember the start and end points so we can contract later
-    ;; unless we're already at maximum size
-    (unless (and (= start best-start)
-                 (= end best-end))
-      (push (cons p1 p2) er/history))
-
-    (when (and expand-region-skip-whitespace
-               (er--point-is-surrounded-by-white-space)
-               (= start end))
-      (skip-chars-forward er--space-str)
-      (setq start (point)))
-
-    (while try-list
-      (er--save-excursion
-       (ignore-errors
-         (funcall (car try-list))
-         (when (and (region-active-p)
-                    (er--this-expansion-is-better start end best-start best-end))
-           (setq best-start (point))
-           (setq best-end (mark))
-           (when (and er--show-expansion-message (not (minibufferp)))
-             (message "%S" (car try-list))))))
-      (setq try-list (cdr try-list)))
-
-    (setq deactivate-mark nil)
-    ;; if smart cursor enabled, decide to put it at start or end of region:
-    (if (and expand-region-smart-cursor
-             (not (= start best-start)))
-        (progn (goto-char best-end)
-               (set-mark best-start))
-      (goto-char best-start)
-      (set-mark best-end))
-
-    (er--copy-region-to-register)
-
-    (when (and (= best-start (point-min))
-               (= best-end (point-max))) ;; We didn't find anything new, so exit early
-      'early-exit)))
-
-(defun er--this-expansion-is-better (start end best-start best-end)
-  "t if the current region is an improvement on previous expansions.
-
-This is provided as a separate function for those that would like
-to override the heuristic."
-  (and
-   (<= (point) start)
-   (>= (mark) end)
-   (> (- (mark) (point)) (- end start))
-   (or (> (point) best-start)
-       (and (= (point) best-start)
-            (< (mark) best-end)))))
-
-;;;###autoload
-(defun er/contract-region (arg)
-  "Contract the selected region to its previous size.
-With prefix argument contracts that many times.
-If prefix argument is negative calls `er/expand-region'.
-If prefix argument is 0 it resets point and mark to their state
-before calling `er/expand-region' for the first time."
-  (interactive "p")
-  (if (< arg 0)
-      (er/expand-region (- arg))
-    (when er/history
-      ;; Be sure to reset them all if called with 0
-      (when (= arg 0)
-        (setq arg (length er/history)))
-
-      (when (not transient-mark-mode)
-        (setq-local transient-mark-mode (cons 'only transient-mark-mode)))
-
-      ;; Advance through the list the desired distance
-      (while (and (cdr er/history)
-                  (> arg 1))
-        (setq arg (- arg 1))
-        (setq er/history (cdr er/history)))
-      ;; Reset point and mark
-      (let* ((last (pop er/history))
-             (start (car last))
-             (end (cdr last)))
-        (goto-char start)
-        (set-mark end)
-
-        (er--copy-region-to-register)
-
-        (when (eq start end)
-          (deactivate-mark)
-          (er/clear-history))))))
-
-(defun er/prepare-for-more-expansions-internal (repeat-key-str)
-  "Return bindings and a message to inform user about them"
-  (let ((msg (format "Type %s to expand again" repeat-key-str))
-        (bindings (list (cons repeat-key-str '(er/expand-region 1)))))
-    ;; If contract and expand are on the same binding, ignore contract
-    (unless (string-equal repeat-key-str expand-region-contract-fast-key)
-      (setq msg (concat msg (format ", %s to contract" expand-region-contract-fast-key)))
-      (push (cons expand-region-contract-fast-key '(er/contract-region 1)) bindings))
-    ;; If reset and either expand or contract are on the same binding, ignore reset
-    (unless (or (string-equal repeat-key-str expand-region-reset-fast-key)
-                (string-equal expand-region-contract-fast-key expand-region-reset-fast-key))
-      (setq msg (concat msg (format ", %s to reset" expand-region-reset-fast-key)))
-      (push (cons expand-region-reset-fast-key '(er/expand-region 0)) bindings))
-    (cons msg bindings)))
-
-(defun er/prepare-for-more-expansions ()
-  "Let one expand more by just pressing the last key."
-  (let* ((repeat-key (event-basic-type last-input-event))
-         (repeat-key-str (single-key-description repeat-key))
-         (msg-and-bindings (er/prepare-for-more-expansions-internal repeat-key-str))
-         (msg (car msg-and-bindings))
-         (bindings (cdr msg-and-bindings)))
-    (when repeat-key
-      (er/set-temporary-overlay-map
-       (let ((map (make-sparse-keymap)))
-         (dolist (binding bindings map)
-           (define-key map (read-kbd-macro (car binding))
-             `(lambda ()
-                (interactive)
-                (setq this-command `,(cadr ',binding))
-                (or (not expand-region-show-usage-message) (minibufferp) (message "%s" ,msg))
-                (eval `,(cdr ',binding))))))
-       t)
-      (or (not expand-region-show-usage-message) (minibufferp) (message "%s" msg)))))
-
-(defalias 'er/set-temporary-overlay-map
-  (if (fboundp 'set-temporary-overlay-map) ;Emacs≥24.3
-      #'set-temporary-overlay-map
-    ;; Backport this function from newer emacs versions
-    (lambda (map &optional keep-pred)
-    "Set a new keymap that will only exist for a short period of time.
-The new keymap to use must be given in the MAP variable. When to
-remove the keymap depends on user input and KEEP-PRED:
-
-- if KEEP-PRED is nil (the default), the keymap disappears as
-  soon as any key is pressed, whether or not the key is in MAP;
-
-- if KEEP-PRED is t, the keymap disappears as soon as a key *not*
-  in MAP is pressed;
-
-- otherwise, KEEP-PRED must be a 0-arguments predicate that will
-  decide if the keymap should be removed (if predicate returns
-  nil) or kept (otherwise). The predicate will be called after
-  each key sequence."
-
-    (let* ((clearfunsym (make-symbol "clear-temporary-overlay-map"))
-           (overlaysym (make-symbol "t"))
-           (alist (list (cons overlaysym map)))
-           (clearfun
-            `(lambda ()
-               (unless ,(cond ((null keep-pred) nil)
-                              ((eq t keep-pred)
-                               `(eq this-command
-                                    (lookup-key ',map
-                                                (this-command-keys-vector))))
-                              (t `(funcall ',keep-pred)))
-                 (remove-hook 'pre-command-hook ',clearfunsym)
-                 (setq emulation-mode-map-alists
-                       (delq ',alist emulation-mode-map-alists))))))
-      (set overlaysym overlaysym)
-      (fset clearfunsym clearfun)
-      (add-hook 'pre-command-hook clearfunsym)
-
-      (push alist emulation-mode-map-alists)))))
-
-(advice-add 'keyboard-quit :before #'er--collapse-region-before)
-(advice-add 'cua-cancel    :before #'er--collapse-region-before)
-(defun er--collapse-region-before (&rest _)
-  ;; FIXME: Re-use `er--first-invocation'?
-  (when (memq last-command '(er/expand-region er/contract-region))
-    (er/contract-region 0)))
-
-(advice-add 'minibuffer-keyboard-quit
-            :around #'er--collapse-region-minibuffer-keyboard-quit)
-(defun er--collapse-region-minibuffer-keyboard-quit (orig-fun &rest args)
-  ;; FIXME: Re-use `er--first-invocation'?
-  (if (memq last-command '(er/expand-region er/contract-region))
-      (er/contract-region 0)
-    (apply orig-fun args)))
-
-
-(defun er/clear-history (&rest _)
-  "Clear the history."
-  (setq er/history '())
-  (remove-hook 'after-change-functions #'er/clear-history t))
-
-(defun er--point-is-surrounded-by-white-space ()
-  (and (or (memq (char-before) er--blank-list)
-           (eq (point) (point-min)))
-       (memq (char-after) er--blank-list)))
-
-(defun er/enable-mode-expansions (mode add-fn)
-  (add-hook (intern (format "%s-hook" mode)) add-fn)
-  (save-window-excursion ;; FIXME: Why?
-    (dolist (buffer (buffer-list))
-      (with-current-buffer buffer
-        (when (derived-mode-p mode)
-          (funcall add-fn))))))
-
-(defun er/enable-minor-mode-expansions (mode add-fn)
-  (add-hook (intern (format "%s-hook" mode)) add-fn)
-  (save-window-excursion
-    (dolist (buffer (buffer-list))
-      (with-current-buffer buffer
-        (when (symbol-value mode)
-          (funcall add-fn))))))
-
-;; Some more performant version of `looking-back'
-
-(defun er/looking-back-on-line (regexp)
-  "Version of `looking-back' that only checks current line."
-  (looking-back regexp (line-beginning-position)))
-
-(defun er/looking-back-exact (s)
-  "Version of `looking-back' that only looks for exact matches, no regexp."
-  (string= s (buffer-substring (- (point) (length s))
-                               (point))))
-
-(defun er/looking-back-max (regexp count)
-  "Version of `looking-back' that only check COUNT chars back."
-  (looking-back regexp (max 1 (- (point) count))))
-
-(provide 'expand-region-core)
-
-;;; expand-region-core.el ends here
diff --git a/.config/emacs/lisp/expand-region/expand-region-custom.el b/.config/emacs/lisp/expand-region/expand-region-custom.el
deleted file mode 100644
index f86f861..0000000
--- a/.config/emacs/lisp/expand-region/expand-region-custom.el
+++ /dev/null
@@ -1,115 +0,0 @@
-;;; expand-region-custom.el --- Increase selected region by semantic units.  -*- lexical-binding: t; -*-
-
-;; Copyright (C) 2012-2023  Free Software Foundation, Inc
-
-;; Author: Magnar Sveen <magnars@gmail.com>
-;; Keywords: marking region
-
-;; This program is free software; you can redistribute it and/or modify
-;; it under the terms of the GNU General Public License as published by
-;; the Free Software Foundation, either version 3 of the License, or
-;; (at your option) any later version.
-
-;; This program is distributed in the hope that it will be useful,
-;; but WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-;; GNU General Public License for more details.
-
-;; You should have received a copy of the GNU General Public License
-;; along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-;;; Commentary:
-
-;; This file holds customization variables.
-
-;;; Code:
-
-;;;###autoload
-(defgroup expand-region nil
-  "Increase selected region by semantic units."
-  :group 'tools)
-
-;;;###autoload
-(defcustom expand-region-preferred-python-mode 'python
-  "The name of your preferred python mode."
-  :type '(choice (const :tag "Emacs' python.el" python)
-                 (const :tag "fgallina's python.el" fgallina-python)
-                 (const :tag "python-mode.el" python-mode)))
-
-;;;###autoload
-(defcustom expand-region-guess-python-mode t
-  "If expand-region should attempt to guess your preferred python mode."
-  :type '(choice (const :tag "Guess" t)
-                 (const :tag "Do not guess" nil)))
-
-(defun expand-region-guess-python-mode ()
-  "Guess the user's preferred python mode."
-  (setq expand-region-preferred-python-mode
-        (if (fboundp 'python-setup-brm)
-            'python
-          'fgallina-python)))
-
-;;;###autoload
-(defcustom expand-region-autocopy-register ""
-  "Register to copy most recent expand or contract to.
-
-Activated when set to a string of a single character (for example, \"e\")."
-  :type 'string)
-
-;;;###autoload
-(defcustom expand-region-skip-whitespace t
-  "If expand-region should skip past whitespace on initial expansion."
-  :type '(choice (const :tag "Skip whitespace" t)
-                 (const :tag "Do not skip whitespace" nil)))
-
-;;;###autoload
-(defcustom expand-region-fast-keys-enabled t
-  "If expand-region should bind fast keys after initial expand/contract."
-  :type '(choice (const :tag "Enable fast keys" t)
-                 (const :tag "Disable fast keys" nil)))
-
-;;;###autoload
-(defcustom expand-region-contract-fast-key "-"
-  "Key to use after an initial expand/contract to contract once more."
-  :type 'string)
-
-;;;###autoload
-(defcustom expand-region-reset-fast-key "0"
-  "Key to use after an initial expand/contract to undo."
-  :type 'string)
-
-;;;###autoload
-(defcustom expand-region-exclude-text-mode-expansions
-  '(html-mode nxml-mode)
-  "List of modes derived from `text-mode' to exclude from text mode expansions."
-  :type '(repeat (symbol :tag "Major Mode" unknown)))
-
-;;;###autoload
-(defcustom expand-region-smart-cursor nil
-  "Defines whether the cursor should be placed intelligently after expansion.
-
-If set to t, and the cursor is already at the beginning of the new region,
-keep it there; otherwise, put it at the end of the region.
-
-If set to nil, always place the cursor at the beginning of the region."
-  :type '(choice (const :tag "Smart behaviour" t)
-                 (const :tag "Standard behaviour" nil)))
-
-;;;###autoload
-(define-obsolete-variable-alias 'er/enable-subword-mode?
-  'expand-region-subword-enabled "2019-03-23")
-
-;;;###autoload
-(defcustom expand-region-subword-enabled nil
-  "Whether expand-region should use subword expansions."
-  :type '(choice (const :tag "Enable subword expansions" t)
-                 (const :tag "Disable subword expansions" nil)))
-
-(defcustom expand-region-show-usage-message t
-  "Whether expand-region should show usage message."
-  :group 'expand-region
-  :type 'boolean)
-
-(provide 'expand-region-custom)
-
-;;; expand-region-custom.el ends here
diff --git a/.config/emacs/lisp/expand-region/expand-region.el b/.config/emacs/lisp/expand-region/expand-region.el
deleted file mode 100644
index 9f63d51..0000000
--- a/.config/emacs/lisp/expand-region/expand-region.el
+++ /dev/null
@@ -1,198 +0,0 @@
-;;; expand-region.el --- Increase selected region by semantic units.  -*- lexical-binding: t; -*-
-
-;; Copyright (C) 2011-2023  Free Software Foundation, Inc
-
-;; Author: Magnar Sveen <magnars@gmail.com>
-;; Keywords: marking region
-;; URL: https://github.com/magnars/expand-region.el
-;; Version: 1.0.0
-;; Package-Requires: ((emacs "24.4"))
-
-;; This program is free software; you can redistribute it and/or modify
-;; it under the terms of the GNU General Public License as published by
-;; the Free Software Foundation, either version 3 of the License, or
-;; (at your option) any later version.
-
-;; This program is distributed in the hope that it will be useful,
-;; but WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-;; GNU General Public License for more details.
-
-;; You should have received a copy of the GNU General Public License
-;; along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-;;; Commentary:
-
-;; Expand region increases the selected region by semantic units. Just keep
-;; pressing the key until it selects what you want.
-
-;; An example:
-
-;;     (setq alphabet-start "abc def")
-
-;; With the cursor at the `c`, it starts by marking the entire word `abc`, then
-;; expand to the contents of the quotes `abc def`, then to the entire quote
-;; `"abc def"`, then to the contents of the sexp `setq alphabet-start "abc def"`
-;; and finally to the entire sexp.
-
-;; You can set it up like this:
-
-;;     (require 'expand-region)
-;;     (global-set-key (kbd "C-=") 'er/expand-region)
-
-;; There's also `er/contract-region` if you expand too far.
-
-;; ## Video
-
-;; You can [watch an intro to expand-region at Emacs Rocks](http://emacsrocks.com/e09.html).
-
-;; ## Language support
-
-;; Expand region works fairly well with most languages, due to the general
-;; nature of the basic expansions:
-
-;;     er/mark-word
-;;     er/mark-symbol
-;;     er/mark-method-call
-;;     er/mark-inside-quotes
-;;     er/mark-outside-quotes
-;;     er/mark-inside-pairs
-;;     er/mark-outside-pairs
-
-;; However, most languages also will benefit from some specially crafted
-;; expansions. For instance, expand-region comes with these extra expansions for
-;; html-mode:
-
-;;     er/mark-html-attribute
-;;     er/mark-inner-tag
-;;     er/mark-outer-tag
-
-;; You can add your own expansions to the languages of your choice simply by
-;; creating a function that looks around point to see if it's inside or looking
-;; at the construct you want to mark, and if so - mark it.
-
-;; There's plenty of examples to look at in these files.
-
-;; After you make your function, add it to a buffer-local version of
-;; the `er/try-expand-list`.
-
-;; **Example:**
-
-;; Let's say you want expand-region to also mark paragraphs and pages in
-;; text-mode. Incidentally Emacs already comes with `mark-paragraph` and
-;; `mark-page`. To add it to the try-list, do this:
-
-;;     (defun er/add-text-mode-expansions ()
-;;       (setq-local er/try-expand-list (append
-;;                                 er/try-expand-list
-;;                                 '(mark-paragraph
-;;                                   mark-page))))
-
-;;     (er/enable-mode-expansions 'text-mode #'er/add-text-mode-expansions)
-
-;; Add that to its own file, and require it at the bottom of this one,
-;; where it says "Mode-specific expansions"
-
-;; **Warning:** Badly written expansions might slow down expand-region
-;; dramatically. Remember to exit quickly before you start traversing
-;; the entire document looking for constructs to mark.
-
-;; ## Contribute
-
-;; If you make some nice expansions for your favorite mode, it would be
-;; great if you opened a pull-request. The repo is at:
-
-;;     https://github.com/magnars/expand-region.el
-
-;; Changes to `expand-region-core` itself must be accompanied by feature tests.
-;; They are written in [Ecukes](http://ecukes.info), a Cucumber for Emacs.
-
-;; To fetch the test dependencies:
-
-;;     $ cd /path/to/expand-region
-;;     $ git submodule init
-;;     $ git submodule update
-
-;; Run the tests with:
-
-;;     $ ./util/ecukes/ecukes features
-
-;; If you want to add feature-tests for your mode-specific expansions as well,
-;; that is utterly excellent.
-
-;; ## Contributors
-
-;; * [Josh Johnston](https://github.com/joshwnj) contributed `er/contract-region`
-;; * [Le Wang](https://github.com/lewang) contributed consistent handling of the mark ring, expanding into pairs/quotes just left of the cursor, and general code clean-up.
-;; * [Matt Briggs](https://github.com/mbriggs) contributed expansions for ruby-mode.
-;; * [Ivan Andrus](https://github.com/gvol) contributed expansions for python-mode, text-mode, LaTeX-mode and nxml-mode.
-;; * [Raimon Grau](https://github.com/kidd) added support for when transient-mark-mode is off.
-;; * [Gleb Peregud](https://github.com/gleber) contributed expansions for erlang-mode.
-;; * [fgeller](https://github.com/fgeller) and [edmccard](https://github.com/edmccard) contributed better support for python and its multiple modes.
-;; * [François Févotte](https://github.com/ffevotte) contributed expansions for C and C++.
-;; * [Roland Walker](https://github.com/rolandwalker) added option to copy the contents of the most recent action to a register, and some fixes.
-;; * [Damien Cassou](https://github.com/DamienCassou) added option to continue expanding/contracting with fast keys after initial expand.
-
-;; Thanks!
-
-;;; Code:
-
-(require 'expand-region-core)
-(require 'expand-region-custom)
-(require 'er-basic-expansions)
-
-;;;###autoload
-(defun er/expand-region (arg)
-  "Increase selected region by semantic units.
-
-With prefix argument expands the region that many times.
-If prefix argument is negative calls `er/contract-region'.
-If prefix argument is 0 it resets point and mark to their state
-before calling `er/expand-region' for the first time."
-  (interactive "p")
-  (if (< arg 1)
-      (er/contract-region (- arg))
-    (er--prepare-expanding)
-    (while (>= arg 1)
-      (setq arg (- arg 1))
-      (when (eq 'early-exit (er--expand-region-1))
-        (setq arg 0)))
-    (when (and expand-region-fast-keys-enabled
-               (not (memq last-command '(er/expand-region er/contract-region))))
-      (er/prepare-for-more-expansions))))
-
-;; (eval-after-load 'clojure-mode   '(require 'clojure-mode-expansions))
-;; (eval-after-load 'erlang-mode    '(require 'erlang-mode-expansions))
-;; (eval-after-load 'feature-mode   '(require 'feature-mode-expansions))
-;; (eval-after-load 'sgml-mode      '(require 'html-mode-expansions)) ;; html-mode is defined in sgml-mode.el
-;; (eval-after-load 'rhtml-mode     '(require 'html-mode-expansions))
-;; (eval-after-load 'nxhtml-mode    '(require 'html-mode-expansions))
-;; (eval-after-load 'web-mode       '(require 'web-mode-expansions))
-;; (eval-after-load 'js             '(require 'js-mode-expansions))
-;; (eval-after-load 'js2-mode       '(require 'js-mode-expansions))
-;; (eval-after-load 'js2-mode       '(require 'js2-mode-expansions))
-;; (eval-after-load 'js3-mode       '(require 'js-mode-expansions))
-;; (eval-after-load 'latex          '(require 'latex-mode-expansions))
-;; (eval-after-load 'nxml-mode      '(require 'nxml-mode-expansions))
-;; (eval-after-load 'octave-mod     '(require 'octave-expansions))
-;; (eval-after-load 'octave         '(require 'octave-expansions))
-;; (eval-after-load 'python         '(progn
-;;                                     (when expand-region-guess-python-mode
-;;                                       (expand-region-guess-python-mode))
-;;                                     (if (eq 'python expand-region-preferred-python-mode)
-;;                                         (require 'python-el-expansions)
-;;                                       (require 'python-el-fgallina-expansions))))
-;; (eval-after-load 'python-mode    '(require 'python-mode-expansions))
-;; (eval-after-load 'ruby-mode      '(require 'ruby-mode-expansions))
-;; (eval-after-load 'org            '(require 'the-org-mode-expansions))
-(eval-after-load 'cc-mode        '(require 'cc-mode-expansions))
-;; (eval-after-load 'text-mode      '(require 'text-mode-expansions))
-;; (eval-after-load 'cperl-mode     '(require 'cperl-mode-expansions))
-;; (eval-after-load 'sml-mode       '(require 'sml-mode-expansions))
-;; (eval-after-load 'enh-ruby-mode  '(require 'enh-ruby-mode-expansions))
-;; (eval-after-load 'subword        '(require 'subword-mode-expansions))
-;; (eval-after-load 'yaml-mode      '(require 'yaml-mode-expansions))
-
-(provide 'expand-region)
-
-;;; expand-region.el ends here