2 files changed, 0 insertions, 3014 deletions
diff --git a/lisp/compat/keymap.el b/lisp/compat/keymap.el
deleted file mode 100644
index 3e9189f..0000000
--- a/lisp/compat/keymap.el
+++ /dev/null

@@ -1,590 +0,0 @@
-;;; keymap.el --- Keymap functions  -*- lexical-binding: t; -*-
-;; Copyright (C) 2021-2022 Free Software Foundation, Inc.
-;; This file is part of GNU Emacs.
-;; GNU Emacs 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.
-;; GNU Emacs 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 GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.
-;;; Commentary:
-;; This library deals with the "new" keymap binding interface: The
-;; only key syntax allowed by these functions is the `kbd' one.
-;;; Code:
-(defun keymap--check (key)
-  "Signal an error if KEY doesn't have a valid syntax."
-  (unless (key-valid-p key)
-    (error "%S is not a valid key definition; see `key-valid-p'" key)))
-(defun keymap--compile-check (&rest keys)
-  (dolist (key keys)
-    (when (or (vectorp key)
-              (and (stringp key) (not (key-valid-p key))))
-      (byte-compile-warn "Invalid `kbd' syntax: %S" key))))
-(defun keymap-set (keymap key definition)
-  "Set KEY to DEFINITION in KEYMAP.
-KEY is a string that satisfies `key-valid-p'.
-DEFINITION is anything that can be a key's definition:
- nil (means key is undefined in this keymap),
- a command (a Lisp function suitable for interactive calling),
- a string (treated as a keyboard macro),
- a keymap (to define a prefix key),
- a symbol (when the key is looked up, the symbol will stand for its
-    function definition, which should at that time be one of the above,
-    or another symbol whose function definition is used, etc.),
- a cons (STRING . DEFN), meaning that DEFN is the definition
-    (DEFN should be a valid definition in its own right) and
-    STRING is the menu item name (which is used only if the containing
-    keymap has been created with a menu name, see `make-keymap'),
- or a cons (MAP . CHAR), meaning use definition of CHAR in keymap MAP,
- or an extended menu item definition.
- (See info node `(elisp)Extended Menu Items'.)"
-  (declare (compiler-macro (lambda (form) (keymap--compile-check key) form)))
-  (keymap--check key)
-  ;; If we're binding this key to another key, then parse that other
-  ;; key, too.
-  (when (stringp definition)
-    (keymap--check definition)
-    (setq definition (key-parse definition)))
-  (define-key keymap (key-parse key) definition))
-(defun keymap-global-set (key command)
-  "Give KEY a global binding as COMMAND.
-COMMAND is the command definition to use; usually it is
-a symbol naming an interactively-callable function.
-KEY is a string that satisfies `key-valid-p'.
-Note that if KEY has a local binding in the current buffer,
-that local binding will continue to shadow any global binding
-that you make with this function."
-  (declare (compiler-macro (lambda (form) (keymap--compile-check key) form)))
-  (interactive
-   (let* ((menu-prompting nil)
-          (key (read-key-sequence "Set key globally: " nil t)))
-     (list key
-           (read-command (format "Set key %s to command: "
-                                 (key-description key))))))
-  (keymap-set (current-global-map) key command))
-(defun keymap-local-set (key command)
-  "Give KEY a local binding as COMMAND.
-COMMAND is the command definition to use; usually it is
-a symbol naming an interactively-callable function.
-KEY is a string that satisfies `key-valid-p'.
-The binding goes in the current buffer's local map, which in most
-cases is shared with all other buffers in the same major mode."
-  (declare (compiler-macro (lambda (form) (keymap--compile-check key) form)))
-  (interactive "KSet key locally: \nCSet key %s locally to command: ")
-  (let ((map (current-local-map)))
-    (unless map
-      (use-local-map (setq map (make-sparse-keymap))))
-    (keymap-set map key command)))
-(defun keymap-global-unset (key &optional remove)
-  "Remove global binding of KEY (if any).
-KEY is a string that satisfies `key-valid-p'.
-If REMOVE (interactively, the prefix arg), remove the binding
-instead of unsetting it.  See `keymap-unset' for details."
-  (declare (compiler-macro (lambda (form) (keymap--compile-check key) form)))
-  (interactive
-   (list (key-description (read-key-sequence "Set key locally: "))
-         current-prefix-arg))
-  (keymap-unset (current-global-map) key remove))
-(defun keymap-local-unset (key &optional remove)
-  "Remove local binding of KEY (if any).
-KEY is a string that satisfies `key-valid-p'.
-If REMOVE (interactively, the prefix arg), remove the binding
-instead of unsetting it.  See `keymap-unset' for details."
-  (declare (compiler-macro (lambda (form) (keymap--compile-check key) form)))
-  (interactive
-   (list (key-description (read-key-sequence "Unset key locally: "))
-         current-prefix-arg))
-  (when (current-local-map)
-    (keymap-unset (current-local-map) key remove)))
-(defun keymap-unset (keymap key &optional remove)
-  "Remove key sequence KEY from KEYMAP.
-KEY is a string that satisfies `key-valid-p'.
-If REMOVE, remove the binding instead of unsetting it.  This only
-makes a difference when there's a parent keymap.  When unsetting
-a key in a child map, it will still shadow the same key in the
-parent keymap.  Removing the binding will allow the key in the
-parent keymap to be used."
-  (declare (compiler-macro (lambda (form) (keymap--compile-check key) form)))
-  (keymap--check key)
-  (define-key keymap (key-parse key) nil remove))
-(defun keymap-substitute (keymap olddef newdef &optional oldmap prefix)
-  "Replace OLDDEF with NEWDEF for any keys in KEYMAP now defined as OLDDEF.
-In other words, OLDDEF is replaced with NEWDEF wherever it appears.
-Alternatively, if optional fourth argument OLDMAP is specified, we redefine
-in KEYMAP as NEWDEF those keys that are defined as OLDDEF in OLDMAP.
-If you don't specify OLDMAP, you can usually get the same results
-in a cleaner way with command remapping, like this:
-  (define-key KEYMAP [remap OLDDEF] NEWDEF)
-\n(fn OLDDEF NEWDEF KEYMAP &optional OLDMAP)"
-  ;; Don't document PREFIX in the doc string because we don't want to
-  ;; advertise it.  It's meant for recursive calls only.  Here's its
-  ;; meaning
-  ;; If optional argument PREFIX is specified, it should be a key
-  ;; prefix, a string.  Redefined bindings will then be bound to the
-  ;; original key, with PREFIX added at the front.
-  (unless prefix
-    (setq prefix ""))
-  (let* ((scan (or oldmap keymap))
-         (prefix1 (vconcat prefix [nil]))
-         (key-substitution-in-progress
-          (cons scan key-substitution-in-progress)))
-    ;; Scan OLDMAP, finding each char or event-symbol that
-    ;; has any definition, and act on it with hack-key.
-    (map-keymap
-     (lambda (char defn)
-       (aset prefix1 (length prefix) char)
-       (substitute-key-definition-key defn olddef newdef prefix1 keymap))
-     scan)))
-(defun keymap-set-after (keymap key definition &optional after)
-  "Add binding in KEYMAP for KEY => DEFINITION, right after AFTER's binding.
-This is like `keymap-set' except that the binding for KEY is placed
-just after the binding for the event AFTER, instead of at the beginning
-of the map.  Note that AFTER must be an event type (like KEY), NOT a command
-\(like DEFINITION).
-If AFTER is t or omitted, the new binding goes at the end of the keymap.
-AFTER should be a single event type--a symbol or a character, not a sequence.
-Bindings are always added before any inherited map.
-The order of bindings in a keymap matters only when it is used as
-a menu, so this function is not useful for non-menu keymaps."
-  (declare (indent defun)
-           (compiler-macro (lambda (form) (keymap--compile-check key) form)))
-  (keymap--check key)
-  (when after
-    (keymap--check after))
-  (define-key-after keymap (key-parse key) definition
-    (and after (key-parse after))))
-(defun key-parse (keys)
-  "Convert KEYS to the internal Emacs key representation.
-See `kbd' for a descripion of KEYS."
-  (declare (pure t) (side-effect-free t))
-  ;; A pure function is expected to preserve the match data.
-  (save-match-data
-    (let ((case-fold-search nil)
-          (len (length keys)) ; We won't alter keys in the loop below.
-          (pos 0)
-          (res []))
-      (while (and (< pos len)
-                  (string-match "[^ \t\n\f]+" keys pos))
-        (let* ((word-beg (match-beginning 0))
-               (word-end (match-end 0))
-               (word (substring keys word-beg len))
-               (times 1)
-               key)
-          ;; Try to catch events of the form "<as df>".
-          (if (string-match "\\`<[^ <>\t\n\f][^>\t\n\f]*>" word)
-              (setq word (match-string 0 word)
-                    pos (+ word-beg (match-end 0)))
-            (setq word (substring keys word-beg word-end)
-                  pos word-end))
-          (when (string-match "\\([0-9]+\\)\\*." word)
-            (setq times (string-to-number (substring word 0 (match-end 1))))
-            (setq word (substring word (1+ (match-end 1)))))
-          (cond ((string-match "^<<.+>>$" word)
-                 (setq key (vconcat (if (eq (key-binding [?\M-x])
-                                            'execute-extended-command)
-                                        [?\M-x]
-                                      (or (car (where-is-internal
-                                                'execute-extended-command))
-                                          [?\M-x]))
-                                    (substring word 2 -2) "\r")))
-                ((and (string-match "^\\(\\([ACHMsS]-\\)*\\)<\\(.+\\)>$" word)
-                      (progn
-                        (setq word (concat (match-string 1 word)
-                                           (match-string 3 word)))
-                        (not (string-match
-                              "\\<\\(NUL\\|RET\\|LFD\\|ESC\\|SPC\\|DEL\\)$"
-                              word))))
-                 (setq key (list (intern word))))
-                ((or (equal word "REM") (string-match "^;;" word))
-                 (setq pos (string-match "$" keys pos)))
-                (t
-                 (let ((orig-word word) (prefix 0) (bits 0))
-                   (while (string-match "^[ACHMsS]-." word)
-                     (setq bits (+ bits
-                                   (cdr
-                                    (assq (aref word 0)
-                                          '((?A . ?\A-\^@) (?C . ?\C-\^@)
-                                            (?H . ?\H-\^@) (?M . ?\M-\^@)
-                                            (?s . ?\s-\^@) (?S . ?\S-\^@))))))
-                     (setq prefix (+ prefix 2))
-                     (setq word (substring word 2)))
-                   (when (string-match "^\\^.$" word)
-                     (setq bits (+ bits ?\C-\^@))
-                     (setq prefix (1+ prefix))
-                     (setq word (substring word 1)))
-                   (let ((found (assoc word '(("NUL" . "\0") ("RET" . "\r")
-                                              ("LFD" . "\n") ("TAB" . "\t")
-                                              ("ESC" . "\e") ("SPC" . " ")
-                                              ("DEL" . "\177")))))
-                     (when found (setq word (cdr found))))
-                   (when (string-match "^\\\\[0-7]+$" word)
-                     (let ((n 0))
-                       (dolist (ch (cdr (string-to-list word)))
-                         (setq n (+ (* n 8) ch -48)))
-                       (setq word (vector n))))
-                   (cond ((= bits 0)
-                          (setq key word))
-                         ((and (= bits ?\M-\^@) (stringp word)
-                               (string-match "^-?[0-9]+$" word))
-                          (setq key (mapcar (lambda (x) (+ x bits))
-                                            (append word nil))))
-                         ((/= (length word) 1)
-                          (error "%s must prefix a single character, not %s"
-                                 (substring orig-word 0 prefix) word))
-                         ((and (/= (logand bits ?\C-\^@) 0) (stringp word)
-                               ;; We used to accept . and ? here,
-                               ;; but . is simply wrong,
-                               ;; and C-? is not used (we use DEL instead).
-                               (string-match "[@-_a-z]" word))
-                          (setq key (list (+ bits (- ?\C-\^@)
-                                             (logand (aref word 0) 31)))))
-                         (t
-                          (setq key (list (+ bits (aref word 0)))))))))
-          (when key
-            (dolist (_ (number-sequence 1 times))
-              (setq res (vconcat res key))))))
-      (if (and (>= (length res) 4)
-               (eq (aref res 0) ?\C-x)
-               (eq (aref res 1) ?\()
-               (eq (aref res (- (length res) 2)) ?\C-x)
-               (eq (aref res (- (length res) 1)) ?\)))
-          (apply #'vector (let ((lres (append res nil)))
-                            ;; Remove the first and last two elements.
-                            (setq lres (cdr (cdr lres)))
-                            (nreverse lres)
-                            (setq lres (cdr (cdr lres)))
-                            (nreverse lres)))
-        res))))
-(defun key-valid-p (keys)
-  "Say whether KEYS is a valid key.
-A key is a string consisting of one or more key strokes.
-The key strokes are separated by single space characters.
-Each key stroke is either a single character, or the name of an
-event, surrounded by angle brackets.  In addition, any key stroke
-may be preceded by one or more modifier keys.  Finally, a limited
-number of characters have a special shorthand syntax.
-Here's some example key sequences.
-  \"f\"           (the key 'f')
-  \"S o m\"       (a three key sequence of the keys 'S', 'o' and 'm')
-  \"C-c o\"       (a two key sequence of the keys 'c' with the control modifier
-                 and then the key 'o')
-  \"H-<left>\"    (the key named \"left\" with the hyper modifier)
-  \"M-RET\"       (the \"return\" key with a meta modifier)
-  \"C-M-<space>\" (the \"space\" key with both the control and meta modifiers)
-These are the characters that have shorthand syntax:
-NUL, RET, TAB, LFD, ESC, SPC, DEL.
-Modifiers have to be specified in this order:
-   A-C-H-M-S-s
-which is
-   Alt-Control-Hyper-Meta-Shift-super"
-  (declare (pure t) (side-effect-free t))
-  (and
-   (stringp keys)
-   (string-match-p "\\`[^ ]+\\( [^ ]+\\)*\\'" keys)
-   (save-match-data
-     (catch 'exit
-       (let ((prefixes
-              "\\(A-\\)?\\(C-\\)?\\(H-\\)?\\(M-\\)?\\(S-\\)?\\(s-\\)?")
-             (case-fold-search nil))
-         (dolist (key (split-string keys " "))
-           ;; Every key might have these modifiers, and they should be
-           ;; in this order.
-           (when (string-match (concat "\\`" prefixes) key)
-             (setq key (substring key (match-end 0))))
-           (unless (or (and (= (length key) 1)
-                            ;; Don't accept control characters as keys.
-                            (not (< (aref key 0) ?\s))
-                            ;; Don't accept Meta'd characters as keys.
-                            (or (multibyte-string-p key)
-                                (not (<= 127 (aref key 0) 255))))
-                       (and (string-match-p "\\`<[-_A-Za-z0-9]+>\\'" key)
-                            ;; Don't allow <M-C-down>.
-                            (= (progn
-                                 (string-match
-                                  (concat "\\`<" prefixes) key)
-                                 (match-end 0))
-                               1))
-                       (string-match-p
-                        "\\`\\(NUL\\|RET\\|TAB\\|LFD\\|ESC\\|SPC\\|DEL\\)\\'"
-                        key))
-             ;; Invalid.
-             (throw 'exit nil)))
-         t)))))
-(defun key-translate (from to)
-  "Translate character FROM to TO on the current terminal.
-This function creates a `keyboard-translate-table' if necessary
-and then modifies one entry in it.
-Both KEY and TO are strings that satisfy `key-valid-p'."
-  (declare (compiler-macro
-            (lambda (form) (keymap--compile-check from to) form)))
-  (keymap--check from)
-  (keymap--check to)
-  (or (char-table-p keyboard-translate-table)
-      (setq keyboard-translate-table
-            (make-char-table 'keyboard-translate-table nil)))
-  (aset keyboard-translate-table (key-parse from) (key-parse to)))
-(defun keymap-lookup (keymap key &optional accept-default no-remap position)
-  "Return the binding for command KEY.
-KEY is a string that satisfies `key-valid-p'.
-If KEYMAP is nil, look up in the current keymaps.  If non-nil, it
-should either be a keymap or a list of keymaps, and only these
-keymap(s) will be consulted.
-The binding is probably a symbol with a function definition.
-Normally, `keymap-lookup' ignores bindings for t, which act as
-default bindings, used when nothing else in the keymap applies;
-this makes it usable as a general function for probing keymaps.
-However, if the optional second argument ACCEPT-DEFAULT is
-non-nil, `keymap-lookup' does recognize the default bindings,
-just as `read-key-sequence' does.
-Like the normal command loop, `keymap-lookup' will remap the
-command resulting from looking up KEY by looking up the command
-in the current keymaps.  However, if the optional third argument
-NO-REMAP is non-nil, `keymap-lookup' returns the unmapped
-command.
-If KEY is a key sequence initiated with the mouse, the used keymaps
-will depend on the clicked mouse position with regard to the buffer
-and possible local keymaps on strings.
-If the optional argument POSITION is non-nil, it specifies a mouse
-position as returned by `event-start' and `event-end', and the lookup
-occurs in the keymaps associated with it instead of KEY.  It can also
-be a number or marker, in which case the keymap properties at the
-specified buffer position instead of point are used."
-  (declare (compiler-macro (lambda (form) (keymap--compile-check key) form)))
-  (keymap--check key)
-  (when (and keymap position)
-    (error "Can't pass in both keymap and position"))
-  (if keymap
-      (let ((value (lookup-key keymap (key-parse key) accept-default)))
-        (if (and (not no-remap)
-                   (symbolp value))
-            (or (command-remapping value) value)
-          value))
-    (key-binding (kbd key) accept-default no-remap position)))
-(defun keymap-local-lookup (keys &optional accept-default)
-  "Return the binding for command KEYS in current local keymap only.
-KEY is a string that satisfies `key-valid-p'.
-The binding is probably a symbol with a function definition.
-If optional argument ACCEPT-DEFAULT is non-nil, recognize default
-bindings; see the description of `keymap-lookup' for more details
-about this."
-  (declare (compiler-macro (lambda (form) (keymap--compile-check keys) form)))
-  (when-let ((map (current-local-map)))
-    (keymap-lookup map keys accept-default)))
-(defun keymap-global-lookup (keys &optional accept-default message)
-  "Return the binding for command KEYS in current global keymap only.
-KEY is a string that satisfies `key-valid-p'.
-The binding is probably a symbol with a function definition.
-This function's return values are the same as those of `keymap-lookup'
-\(which see).
-If optional argument ACCEPT-DEFAULT is non-nil, recognize default
-bindings; see the description of `keymap-lookup' for more details
-about this.
-If MESSAGE (and interactively), message the result."
-  (declare (compiler-macro (lambda (form) (keymap--compile-check keys) form)))
-  (interactive
-   (list (key-description (read-key-sequence "Look up key in global keymap: "))
-         nil t))
-  (let ((def (keymap-lookup (current-global-map) keys accept-default)))
-    (when message
-      (message "%s is bound to %s globally" keys def))
-    def))
-;;; define-keymap and defvar-keymap
-(defun define-keymap--compile (form &rest args)
-  ;; This compiler macro is only there for compile-time
-  ;; error-checking; it does not change the call in any way.
-  (while (and args
-              (keywordp (car args))
-              (not (eq (car args) :menu)))
-    (unless (memq (car args) '(:full :keymap :parent :suppress :name :prefix))
-      (byte-compile-warn "Invalid keyword: %s" (car args)))
-    (setq args (cdr args))
-    (when (null args)
-      (byte-compile-warn "Uneven number of keywords in %S" form))
-    (setq args (cdr args)))
-  ;; Bindings.
-  (while args
-    (let ((key (pop args)))
-      (when (and (stringp key) (not (key-valid-p key)))
-        (byte-compile-warn "Invalid `kbd' syntax: %S" key)))
-    (when (null args)
-      (byte-compile-warn "Uneven number of key bindings in %S" form))
-    (setq args (cdr args)))
-  form)
-(defun define-keymap (&rest definitions)
-  "Create a new keymap and define KEY/DEFINITION pairs as key bindings.
-The new keymap is returned.
-Options can be given as keywords before the KEY/DEFINITION
-pairs.  Available keywords are:
-:full      If non-nil, create a chartable alist (see `make-keymap').
-             If nil (i.e., the default), create a sparse keymap (see
-             `make-sparse-keymap').
-:suppress  If non-nil, the keymap will be suppressed (see `suppress-keymap').
-             If `nodigits', treat digits like other chars.
-:parent    If non-nil, this should be a keymap to use as the parent
-             (see `set-keymap-parent').
-:keymap    If non-nil, instead of creating a new keymap, the given keymap
-             will be destructively modified instead.
-:name      If non-nil, this should be a string to use as the menu for
-             the keymap in case you use it as a menu with `x-popup-menu'.
-:prefix    If non-nil, this should be a symbol to be used as a prefix
-             command (see `define-prefix-command').  If this is the case,
-             this symbol is returned instead of the map itself.
-KEY/DEFINITION pairs are as KEY and DEF in `keymap-set'.  KEY can
-also be the special symbol `:menu', in which case DEFINITION
-should be a MENU form as accepted by `easy-menu-define'.
-\(fn &key FULL PARENT SUPPRESS NAME PREFIX KEYMAP &rest [KEY DEFINITION]...)"
-  (declare (indent defun)
-           (compiler-macro define-keymap--compile))
-  (let (full suppress parent name prefix keymap)
-    ;; Handle keywords.
-    (while (and definitions
-                (keywordp (car definitions))
-                (not (eq (car definitions) :menu)))
-      (let ((keyword (pop definitions)))
-        (unless definitions
-          (error "Missing keyword value for %s" keyword))
-        (let ((value (pop definitions)))
-          (pcase keyword
-            (:full (setq full value))
-            (:keymap (setq keymap value))
-            (:parent (setq parent value))
-            (:suppress (setq suppress value))
-            (:name (setq name value))
-            (:prefix (setq prefix value))
-            (_ (error "Invalid keyword: %s" keyword))))))
-    (when (and prefix
-               (or full parent suppress keymap))
-      (error "A prefix keymap can't be defined with :full/:parent/:suppress/:keymap keywords"))
-    (when (and keymap full)
-      (error "Invalid combination: :keymap with :full"))
-    (let ((keymap (cond
-                   (keymap keymap)
-                   (prefix (define-prefix-command prefix nil name))
-                   (full (make-keymap name))
-                   (t (make-sparse-keymap name)))))
-      (when suppress
-        (suppress-keymap keymap (eq suppress 'nodigits)))
-      (when parent
-        (set-keymap-parent keymap parent))
-      ;; Do the bindings.
-      (while definitions
-        (let ((key (pop definitions)))
-          (unless definitions
-            (error "Uneven number of key/definition pairs"))
-          (let ((def (pop definitions)))
-            (if (eq key :menu)
-                (easy-menu-define nil keymap "" def)
-              (keymap-set keymap key def)))))
-      keymap)))
-(defmacro defvar-keymap (variable-name &rest defs)
-  "Define VARIABLE-NAME as a variable with a keymap definition.
-See `define-keymap' for an explanation of the keywords and KEY/DEFINITION.
-In addition to the keywords accepted by `define-keymap', this
-macro also accepts a `:doc' keyword, which (if present) is used
-as the variable documentation string.
-\(fn VARIABLE-NAME &key DOC FULL PARENT SUPPRESS NAME PREFIX KEYMAP &rest [KEY DEFINITION]...)"
-  (declare (indent 1))
-  (let ((opts nil)
-        doc)
-    (while (and defs
-                (keywordp (car defs))
-                (not (eq (car defs) :menu)))
-      (let ((keyword (pop defs)))
-        (unless defs
-          (error "Uneven number of keywords"))
-        (if (eq keyword :doc)
-            (setq doc (pop defs))
-          (push keyword opts)
-          (push (pop defs) opts))))
-    (unless (zerop (% (length defs) 2))
-      (error "Uneven number of key/definition pairs: %s" defs))
-    `(defvar ,variable-name
-       (define-keymap ,@(nreverse opts) ,@defs)
-       ,@(and doc (list doc)))))
-(provide 'keymap)
-;;; keymap.el ends here
diff --git a/lisp/compat/tab-bar.el b/lisp/compat/tab-bar.el
deleted file mode 100644
index d49fc2e..0000000
--- a/lisp/compat/tab-bar.el
+++ /dev/null

@@ -1,2424 +0,0 @@
-;;; tab-bar.el --- frame-local tabs with named persistent window configurations -*- lexical-binding: t; -*-
-;; Copyright (C) 2019-2022 Free Software Foundation, Inc.
-;; Author: Juri Linkov <juri@linkov.net>
-;; Keywords: frames tabs
-;; Maintainer: emacs-devel@gnu.org
-;; This file is part of GNU Emacs.
-;; GNU Emacs 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.
-;; GNU Emacs 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 GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.
-;;; Commentary:
-;; Provides `tab-bar-mode' to control display of the tab bar and
-;; bindings for the global tab bar.
-;; The normal global binding for [tab-bar] (below) uses the value of
-;; `tab-bar-map' as the actual keymap to define the tab bar.
-;;; Code:
-(eval-when-compile
-  (require 'cl-lib)
-  (require 'seq))
-(defgroup tab-bar nil
-  "Frame-local tabs."
-  :group 'convenience
-  :version "27.1")
-(defgroup tab-bar-faces '((tab-bar custom-face)) ; tab-bar is defined in faces.el
-  "Faces used in the tab bar."
-  :group 'tab-bar
-  :group 'faces
-  :version "27.1")
-(defface tab-bar-tab
-  '((default
-      :inherit tab-bar)
-    (((class color) (min-colors 88))
-     :box (:line-width 1 :style released-button))
-    (t
-     :inverse-video nil))
-  "Tab bar face for selected tab."
-  :version "27.1"
-  :group 'tab-bar-faces)
-(defface tab-bar-tab-inactive
-  '((default
-      :inherit tab-bar-tab)
-    (((class color) (min-colors 88))
-     :background "grey75")
-    (t
-     :inverse-video t))
-  "Tab bar face for non-selected tab."
-  :version "27.1"
-  :group 'tab-bar-faces)
-(defface tab-bar-tab-group-current
-  '((t :inherit tab-bar-tab :box nil :weight bold))
-  "Tab bar face for current group tab."
-  :version "28.1"
-  :group 'tab-bar-faces)
-(defface tab-bar-tab-group-inactive
-  '((t :inherit (shadow tab-bar-tab-inactive)))
-  "Tab bar face for inactive group tab."
-  :version "28.1"
-  :group 'tab-bar-faces)
-(defface tab-bar-tab-ungrouped
-  '((t :inherit (shadow tab-bar-tab-inactive)))
-  "Tab bar face for ungrouped tab when tab groups are used."
-  :version "28.1"
-  :group 'tab-bar-faces)
-(defcustom tab-bar-select-tab-modifiers '()
-  "List of modifier keys for selecting tab-bar tabs by their numbers.
-Possible modifier keys are `control', `meta', `shift', `hyper', `super' and
-`alt'.  Pressing one of the modifiers in the list and a digit selects the
-tab whose number equals the digit (see `tab-bar-select-tab').
-The digit 9 selects the last (rightmost) tab (see `tab-last').
-The digit 0 selects the most recently visited tab (see `tab-recent').
-For easier selection of tabs by their numbers, consider customizing
-`tab-bar-tab-hints', which will show tab numbers alongside the tab name."
-  :type '(set :tag "Tab selection modifier keys"
-              (const control)
-              (const meta)
-              (const shift)
-              (const hyper)
-              (const super)
-              (const alt))
-  :initialize 'custom-initialize-default
-  :set (lambda (sym val)
-         (set-default sym val)
-         ;; Reenable the tab-bar with new keybindings
-         (when tab-bar-mode
-           (tab-bar--undefine-keys)
-           (tab-bar--define-keys)))
-  :group 'tab-bar
-  :version "27.1")
-(defun tab-bar--define-keys ()
-  "Install key bindings for switching between tabs if the user has configured them."
-  (when tab-bar-select-tab-modifiers
-    (global-set-key (vector (append tab-bar-select-tab-modifiers (list ?0)))
-                    'tab-recent)
-    (dotimes (i 8)
-      (global-set-key (vector (append tab-bar-select-tab-modifiers
-                                      (list (+ i 1 ?0))))
-                      'tab-bar-select-tab))
-    (global-set-key (vector (append tab-bar-select-tab-modifiers (list ?9)))
-                    'tab-last))
-  ;; Don't override user customized key bindings
-  (unless (global-key-binding [(control tab)])
-    (global-set-key [(control tab)] 'tab-next))
-  (unless (global-key-binding [(control shift tab)])
-    (global-set-key [(control shift tab)] 'tab-previous))
-  (unless (global-key-binding [(control shift iso-lefttab)])
-    (global-set-key [(control shift iso-lefttab)] 'tab-previous))
-  ;; Replace default value with a condition that supports displaying
-  ;; global-mode-string in the tab bar instead of the mode line.
-  (when (and (memq 'tab-bar-format-global tab-bar-format)
-             (member '(global-mode-string ("" global-mode-string))
-                     mode-line-misc-info))
-    (setf (alist-get 'global-mode-string mode-line-misc-info)
-          '(("" (:eval (if (and tab-bar-mode
-                                (memq 'tab-bar-format-global
-                                      tab-bar-format))
-                           "" global-mode-string)))))))
-(defun tab-bar--undefine-keys ()
-  "Uninstall key bindings previously bound by `tab-bar--define-keys'."
-  (when (eq (global-key-binding [(control tab)]) 'tab-next)
-    (global-unset-key [(control tab)]))
-  (when (eq (global-key-binding [(control shift tab)]) 'tab-previous)
-    (global-unset-key [(control shift tab)]))
-  (when (eq (global-key-binding [(control shift iso-lefttab)]) 'tab-previous)
-    (global-unset-key [(control shift iso-lefttab)])))
-(defun tab-bar--load-buttons ()
-  "Load the icons for the tab buttons."
-  (when (and tab-bar-new-button
-             (not (get-text-property 0 'display tab-bar-new-button)))
-    ;; This file is pre-loaded so only here we can use the right data-directory:
-    (add-text-properties 0 (length tab-bar-new-button)
-                         `(display (image :type xpm
-                                          :file "tabs/new.xpm"
-                                          :margin ,tab-bar-button-margin
-                                          :ascent center))
-                         tab-bar-new-button))
-  (when (and tab-bar-close-button
-             (not (get-text-property 0 'display tab-bar-close-button)))
-    ;; This file is pre-loaded so only here we can use the right data-directory:
-    (add-text-properties 0 (length tab-bar-close-button)
-                         `(display (image :type xpm
-                                          :file "tabs/close.xpm"
-                                          :margin ,tab-bar-button-margin
-                                          :ascent center))
-                         tab-bar-close-button)))
-(defun tab-bar--tab-bar-lines-for-frame (frame)
-  "Determine and return the value of `tab-bar-lines' for FRAME.
-Return 0 if `tab-bar-mode' is not enabled.  Otherwise return
-either 1 or 0 depending on the value of the customizable variable
-`tab-bar-show', which see."
-  (cond
-   ((not tab-bar-mode) 0)
-   ((not tab-bar-show) 0)
-   ((eq tab-bar-show t) 1)
-   ((natnump tab-bar-show)
-    (if (> (length (funcall tab-bar-tabs-function frame)) tab-bar-show) 1 0))))
-(defun tab-bar--update-tab-bar-lines (&optional frames)
-  "Update the `tab-bar-lines' frame parameter in FRAMES.
-If the optional parameter FRAMES is omitted, update only
-the currently selected frame.  If it is t, update all frames
-as well as the default for new frames.  Otherwise FRAMES should be
-a list of frames to update."
-  (let ((frame-lst (cond ((null frames)
-                          (list (selected-frame)))
-                         ((eq frames t)
-                          (frame-list))
-                         (t frames))))
-    ;; Loop over all frames and update `tab-bar-lines'
-    (dolist (frame frame-lst)
-      (unless (frame-parameter frame 'tab-bar-lines-keep-state)
-        (set-frame-parameter frame 'tab-bar-lines
-                             (tab-bar--tab-bar-lines-for-frame frame)))))
-  ;; Update `default-frame-alist'
-  (when (eq frames t)
-    (setq default-frame-alist
-          (cons (cons 'tab-bar-lines (if (and tab-bar-mode (eq tab-bar-show t)) 1 0))
-                (assq-delete-all 'tab-bar-lines default-frame-alist)))))
-(define-minor-mode tab-bar-mode
-  "Toggle the tab bar in all graphical frames (Tab Bar mode)."
-  :global t
-  ;; It's defined in C/cus-start, this stops the d-m-m macro defining it again.
-  :variable tab-bar-mode
-  ;; Recalculate `tab-bar-lines' for all frames
-  (tab-bar--update-tab-bar-lines t)
-  (when tab-bar-mode
-    (tab-bar--load-buttons))
-  (if tab-bar-mode
-      (tab-bar--define-keys)
-    (tab-bar--undefine-keys)))
-;;; Key bindings
-(defun tab-bar--key-to-number (key)
-  "Return the tab number represented by KEY.
-If KEY is a symbol 'tab-N', where N is a tab number, the value is N.
-If KEY is \\='current-tab, the value is nil.
-For any other value of KEY, the value is t."
-  (cond
-   ((null key) t)
-   ((eq key 'current-tab) nil)
-   ((let ((key-name (format "%S" key)))
-      (when (string-prefix-p "tab-" key-name)
-        (string-to-number (string-replace "tab-" "" key-name)))))
-   (t t)))
-(defvar tab-bar--dragging-in-progress)
-(defun tab-bar--event-to-item (posn)
-  "This function extracts extra info from the mouse event at position POSN.
-It returns a list of the form (KEY KEY-BINDING CLOSE-P), where:
- KEY is a symbol representing a tab, such as \\='tab-1 or \\='current-tab;
- KEY-BINDING is the binding of KEY;
- CLOSE-P is non-nil if the mouse event was a click on the close button \"x\",
-   nil otherwise."
-  (setq tab-bar--dragging-in-progress nil)
-  (if (posn-window posn)
-      (let ((caption (car (posn-string posn))))
-        (when caption
-          (get-text-property 0 'menu-item caption)))
-    ;; Text-mode emulation of switching tabs on the tab bar.
-    ;; This code is used when you click the mouse in the tab bar
-    ;; on a console which has no window system but does have a mouse.
-    (let* ((x-position (car (posn-x-y posn)))
-           (keymap (lookup-key (cons 'keymap (nreverse (current-active-maps))) [tab-bar]))
-           (column 0))
-      (when x-position
-        (catch 'done
-          (map-keymap
-           (lambda (key binding)
-             (when (eq (car-safe binding) 'menu-item)
-               (when (> (+ column (length (nth 1 binding))) x-position)
-                 (throw 'done (list key (nth 2 binding)
-                                    (get-text-property
-                                     (- x-position column)
-                                     'close-tab (nth 1 binding)))))
-               (setq column (+ column (length (nth 1 binding))))))
-           keymap))))))
-(defun tab-bar-mouse-down-1 (event)
-  "Select the tab at mouse click, or add a new tab on the tab bar.
-Whether this command adds a new tab or selects an existing tab
-depends on whether the click is on the \"+\" button or on an
-existing tab."
-  (interactive "e")
-  (let* ((item (tab-bar--event-to-item (event-start event)))
-         (tab-number (tab-bar--key-to-number (nth 0 item))))
-    (setq tab-bar--dragging-in-progress t)
-    ;; Don't close the tab when clicked on the close button.  Also
-    ;; don't add new tab on down-mouse.  Let `tab-bar-mouse-1' do this.
-    (unless (or (memq (car item) '(add-tab history-back history-forward))
-                (nth 2 item))
-      (if (functionp (nth 1 item))
-          (call-interactively (nth 1 item))
-        (unless (eq tab-number t)
-          (tab-bar-select-tab tab-number))))))
-(defun tab-bar-mouse-1 (event)
-  "Close the tab whose \"x\" close button you click.
-See also `tab-bar-mouse-close-tab', which closes the tab
-regardless of where you click on it.  Also add a new tab."
-  (interactive "e")
-  (let* ((item (tab-bar--event-to-item (event-start event)))
-         (tab-number (tab-bar--key-to-number (nth 0 item))))
-    (cond
-     ((and (memq (car item) '(add-tab history-back history-forward))
-           (functionp (nth 1 item)))
-      (call-interactively (nth 1 item)))
-     ((and (nth 2 item) (not (eq tab-number t)))
-      (tab-bar-close-tab tab-number)))))
-(defun tab-bar-mouse-close-tab (event)
-  "Close the tab you click on.
-This is in contrast with `tab-bar-mouse-1' that closes a tab
-only when you click on its \"x\" close button."
-  (interactive "e")
-  (let* ((item (tab-bar--event-to-item (event-start event)))
-         (tab-number (tab-bar--key-to-number (nth 0 item))))
-    (unless (eq tab-number t)
-      (tab-bar-close-tab tab-number))))
-(defun tab-bar-mouse-context-menu (event)
-  "Pop up the context menu for the tab on which you click."
-  (interactive "e")
-  (let* ((item (tab-bar--event-to-item (event-start event)))
-         (tab-number (tab-bar--key-to-number (nth 0 item)))
-         (menu (make-sparse-keymap (propertize "Context Menu" 'hide t))))
-    (cond
-     ((eq tab-number t)
-      (define-key-after menu [new-tab]
-        '(menu-item "New tab" tab-bar-new-tab
-                    :help "Create a new tab"))
-      (when tab-bar-closed-tabs
-        (define-key-after menu [undo-close]
-          '(menu-item "Reopen closed tab" tab-bar-undo-close-tab
-                      :help "Undo closing the tab"))))
-     (t
-      (define-key-after menu [duplicate-tab]
-        `(menu-item "Duplicate" (lambda () (interactive)
-                                  (tab-bar-duplicate-tab
-                                   nil ,tab-number))
-                    :help "Clone the tab"))
-      (define-key-after menu [detach-tab]
-        `(menu-item "Detach" (lambda () (interactive)
-                               (tab-bar-detach-tab
-                                ,tab-number))
-                    :help "Move the tab to new frame"))
-      (define-key-after menu [close]
-        `(menu-item "Close" (lambda () (interactive)
-                              (tab-bar-close-tab ,tab-number))
-                    :help "Close the tab"))
-      (define-key-after menu [close-other]
-        `(menu-item "Close other tabs"
-                    (lambda () (interactive)
-                      (tab-bar-close-other-tabs ,tab-number))
-                    :help "Close all other tabs"))))
-    (popup-menu menu event)))
-(defun tab-bar-mouse-move-tab (event)
-  "Move a tab to a different position on the tab bar.
-This command should be bound to a drag event.  It moves the tab
-at the mouse-down event to the position at mouse-up event."
-  (interactive "e")
-  (setq tab-bar--dragging-in-progress nil)
-  (let ((from (tab-bar--key-to-number
-               (nth 0 (tab-bar--event-to-item
-                       (event-start event)))))
-        (to (tab-bar--key-to-number
-             (nth 0 (tab-bar--event-to-item
-                     (event-end event))))))
-    (unless (or (eq from to) (eq from t) (eq to t))
-      (tab-bar-move-tab-to
-       (if (null to) (1+ (tab-bar--current-tab-index)) to) from))))
-(defvar tab-bar-map
-  (let ((map (make-sparse-keymap)))
-    (define-key map [down-mouse-1] 'tab-bar-mouse-down-1)
-    (define-key map [drag-mouse-1] 'tab-bar-mouse-move-tab)
-    (define-key map [mouse-1]      'tab-bar-mouse-1)
-    (define-key map [down-mouse-2] 'tab-bar-mouse-close-tab)
-    (define-key map [mouse-2]      'ignore)
-    (define-key map [down-mouse-3] 'tab-bar-mouse-context-menu)
-    (define-key map [mouse-4]     'tab-previous)
-    (define-key map [mouse-5]     'tab-next)
-    (define-key map [wheel-up]    'tab-previous)
-    (define-key map [wheel-down]  'tab-next)
-    (define-key map [wheel-left]  'tab-previous)
-    (define-key map [wheel-right] 'tab-next)
-    (define-key map [S-mouse-4]     'tab-bar-move-tab-backward)
-    (define-key map [S-mouse-5]     'tab-bar-move-tab)
-    (define-key map [S-wheel-up]    'tab-bar-move-tab-backward)
-    (define-key map [S-wheel-down]  'tab-bar-move-tab)
-    (define-key map [S-wheel-left]  'tab-bar-move-tab-backward)
-    (define-key map [S-wheel-right] 'tab-bar-move-tab)
-    map)
-  "Keymap for the commands used on the tab bar.")
-(global-set-key [tab-bar]
-                `(menu-item ,(purecopy "tab bar") ignore
-                            :filter tab-bar-make-keymap))
-(defun tab-bar-make-keymap (&optional _ignore)
-  "Generate an actual keymap from `tab-bar-map'.
-Its main job is to show tabs in the tab bar
-and to bind mouse events to the commands."
-  (tab-bar-make-keymap-1))
-(defun toggle-tab-bar-mode-from-frame (&optional arg)
-  "Toggle tab bar on or off, based on the status of the current frame.
-Used in the Show/Hide menu, to have the toggle reflect the current frame.
-See `tab-bar-mode' for more information."
-  (interactive (list (or current-prefix-arg 'toggle)))
-  (if (eq arg 'toggle)
-      (tab-bar-mode (if (> (frame-parameter nil 'tab-bar-lines) 0) 0 1))
-    (tab-bar-mode arg)))
-(defun toggle-frame-tab-bar (&optional frame)
-  "Toggle tab bar of the selected frame.
-When calling from Lisp, use the optional argument FRAME to toggle
-the tab bar on that frame.
-This is useful if you want to enable the tab bar individually
-on each new frame when the global `tab-bar-mode' is disabled,
-or if you want to disable the tab bar individually on each
-new frame when the global `tab-bar-mode' is enabled, by using
-  (add-hook 'after-make-frame-functions 'toggle-frame-tab-bar)"
-  (interactive)
-  (set-frame-parameter frame 'tab-bar-lines
-                       (if (> (frame-parameter frame 'tab-bar-lines) 0) 0 1))
-  (set-frame-parameter frame 'tab-bar-lines-keep-state
-                       (not (frame-parameter frame 'tab-bar-lines-keep-state))))
-(defcustom tab-bar-show t
-  "Defines when to show the tab bar.
-If t, the default, enable `tab-bar-mode' automatically upon using
-the commands that create new window configurations (e.g., `tab-new').
-If a non-negative integer, show the tab bar only if the number of
-the tabs exceeds the value of this variable.  In particular,
-if the value is 1, hide the tab bar when it has only one tab, and
-show it again once more tabs are created.  A value that is a
-non-negative integer also makes the tab bar appearance be different
-on different frames: the tab bar can be shown on some frames and
-hidden on others, depending on how many tab-bar tabs are on that
-frame, and whether that number is greater than the numerical value
-of this variable.
-If nil, always keep the tab bar hidden.  In this case it's still
-possible to use persistent named window configurations by relying on
-keyboard commands `tab-new', `tab-close', `tab-next', `tab-switcher', etc.
-Setting this variable directly does not take effect; please customize
-it (see the info node `Easy Customization'), then it will automatically
-update the tab bar on all frames according to the new value.
-To enable or disable the tab bar individually on each frame,
-you can use the command `toggle-frame-tab-bar'."
-  :type '(choice (const :tag "Always" t)
-                 (const :tag "When more than one tab" 1)
-                 (const :tag "Never" nil))
-  :initialize 'custom-initialize-default
-  :set (lambda (sym val)
-         (set-default sym val)
-         (if val
-             (tab-bar-mode 1)
-           (tab-bar--update-tab-bar-lines t)))
-  :group 'tab-bar
-  :version "27.1")
-(defcustom tab-bar-new-tab-choice t
-  "Defines what to show in a new tab.
-If t, start a new tab with the current buffer, i.e. the buffer
-that was current before calling the command that adds a new tab
-(this is the same what `make-frame' does by default).
-If the value is a string, use it as a buffer name to switch to
-if such buffer exists, or switch to a buffer visiting the file or
-directory that the string specifies.  If the value is a function,
-call it with no arguments and switch to the buffer that it returns.
-If nil, duplicate the contents of the tab that was active
-before calling the command that adds a new tab."
-  :type '(choice (const     :tag "Current buffer" t)
-                 (string    :tag "Buffer" "*scratch*")
-                 (directory :tag "Directory" :value "~/")
-                 (file      :tag "File" :value "~/.emacs")
-                 (function  :tag "Function")
-                 (const     :tag "Duplicate tab" nil))
-  :group 'tab-bar
-  :version "27.1")
-(defcustom tab-bar-new-tab-group t
-  "Defines what group to assign to a new tab.
-If nil, don't set a default group automatically.
-If t, inherit the group name from the previous tab.
-If the value is a string, use it as the group name of a new tab.
-If the value is a function, call it with no arguments
-to get the group name."
-  :type '(choice (const    :tag "No automatic group" nil)
-                 (const    :tag "Inherit group from previous tab" t)
-                 (string   :tag "Fixed group name")
-                 (function :tag "Function that returns group name"))
-  :group 'tab-bar
-  :version "28.1")
-(defcustom tab-bar-new-button-show t
-  "If non-nil, show the \"New tab\" button in the tab bar.
-When this is nil, you can create new tabs with \\[tab-new]."
-  :type 'boolean
-  :initialize 'custom-initialize-default
-  :set (lambda (sym val)
-         (set-default sym val)
-         (force-mode-line-update))
-  :group 'tab-bar
-  :version "27.1")
-(make-obsolete-variable 'tab-bar-new-button-show 'tab-bar-format "28.1")
-(defvar tab-bar-new-button " + "
-  "Button for creating a new tab.")
-(defcustom tab-bar-close-button-show t
-  "Defines where to show the close tab button.
-If t, show the close tab button on all tabs.
-If `selected', show it only on the selected tab.
-If `non-selected', show it only on non-selected tab.
-If nil, don't show it at all."
-  :type '(choice (const :tag "On all tabs" t)
-                 (const :tag "On selected tab" selected)
-                 (const :tag "On non-selected tabs" non-selected)
-                 (const :tag "None" nil))
-  :initialize 'custom-initialize-default
-  :set (lambda (sym val)
-         (set-default sym val)
-         (force-mode-line-update))
-  :group 'tab-bar
-  :version "27.1")
-(defvar tab-bar-close-button
-  (propertize " x"
-              'close-tab t
-              :help "Click to close tab")
-  "Button for closing the clicked tab.")
-(defvar tab-bar-back-button " < "
-  "Button for going back in tab history.")
-(defvar tab-bar-forward-button " > "
-  "Button for going forward in tab history.")
-(defcustom tab-bar-tab-hints nil
-  "Show absolute numbers on tabs in the tab bar before the tab name.
-This helps to select the tab by its number using `tab-bar-select-tab'
-and `tab-bar-select-tab-modifiers'."
-  :type 'boolean
-  :initialize 'custom-initialize-default
-  :set (lambda (sym val)
-         (set-default sym val)
-         (force-mode-line-update))
-  :group 'tab-bar
-  :version "27.1")
-(defvar tab-bar-separator nil
-  "String that delimits tabs.")
-(defun tab-bar-separator ()
-  "Separator between tabs."
-  (or tab-bar-separator (if window-system " " "|")))
-(defcustom tab-bar-tab-name-function #'tab-bar-tab-name-current
-  "Function to get a tab name.
-Function gets no arguments.
-The choice is between displaying only the name of the current buffer
-in the tab name (default), or displaying the names of all buffers
-from all windows in the window configuration."
-  :type '(choice (const :tag "Selected window buffer"
-                        tab-bar-tab-name-current)
-                 (const :tag "Selected window buffer with window count"
-                        tab-bar-tab-name-current-with-count)
-                 (const :tag "Truncated buffer name"
-                        tab-bar-tab-name-truncated)
-                 (const :tag "All window buffers"
-                        tab-bar-tab-name-all)
-                 (function  :tag "Function"))
-  :initialize 'custom-initialize-default
-  :set (lambda (sym val)
-         (set-default sym val)
-         (force-mode-line-update))
-  :group 'tab-bar
-  :version "27.1")
-(defun tab-bar-tab-name-current ()
-  "Generate tab name from the buffer of the selected window."
-  (buffer-name (window-buffer (minibuffer-selected-window))))
-(defun tab-bar-tab-name-current-with-count ()
-  "Generate tab name from the buffer of the selected window.
-Also add the number of windows in the window configuration."
-  (let ((count (length (window-list-1 nil 'nomini)))
-        (name (window-buffer (minibuffer-selected-window))))
-    (if (> count 1)
-        (format "%s (%d)" name count)
-      (format "%s" name))))
-(defun tab-bar-tab-name-all ()
-  "Generate tab name from buffers of all windows."
-  (mapconcat #'buffer-name
-             (delete-dups (mapcar #'window-buffer
-                                  (window-list-1 (frame-first-window)
-                                                 'nomini)))
-             ", "))
-(defcustom tab-bar-tab-name-truncated-max 20
-  "Maximum length of the tab name from the current buffer.
-Effective when `tab-bar-tab-name-function' is customized
-to `tab-bar-tab-name-truncated'."
-  :type 'integer
-  :group 'tab-bar
-  :version "27.1")
-(defvar tab-bar-tab-name-ellipsis t)
-(defun tab-bar-tab-name-truncated ()
-  "Generate tab name from the buffer of the selected window.
-Truncate it to the length specified by `tab-bar-tab-name-truncated-max'.
-Append ellipsis `tab-bar-tab-name-ellipsis' in this case."
-  (let ((tab-name (buffer-name (window-buffer (minibuffer-selected-window)))))
-    (if (< (length tab-name) tab-bar-tab-name-truncated-max)
-        tab-name
-      (propertize (truncate-string-to-width
-                   tab-name tab-bar-tab-name-truncated-max nil nil
-                   tab-bar-tab-name-ellipsis)
-                  'help-echo tab-name))))
-(defvar tab-bar-tabs-function #'tab-bar-tabs
-  "Function to get a list of tabs to display in the tab bar.
-This function should have one optional argument FRAME,
-defaulting to the selected frame when nil.
-It should return a list of alists with parameters
-that include at least the element (name . TAB-NAME).
-For example, \\='((tab (name . \"Tab 1\")) (current-tab (name . \"Tab 2\")))
-By default, use function `tab-bar-tabs'.")
-(defun tab-bar-tabs (&optional frame)
-  "Return a list of tabs belonging to the FRAME.
-Ensure the frame parameter `tabs' is pre-populated.
-Update the current tab name when it exists.
-Return its existing value or a new value."
-  (let ((tabs (frame-parameter frame 'tabs)))
-    (if tabs
-        (let* ((current-tab (tab-bar--current-tab-find tabs))
-               (current-tab-name (assq 'name current-tab))
-               (current-tab-explicit-name (assq 'explicit-name current-tab)))
-          (when (and current-tab-name
-                     current-tab-explicit-name
-                     (not (cdr current-tab-explicit-name)))
-            (setf (cdr current-tab-name)
-                  (funcall tab-bar-tab-name-function))))
-      ;; Create default tabs
-      (setq tabs (list (tab-bar--current-tab-make)))
-      (tab-bar-tabs-set tabs frame))
-    tabs))
-(defun tab-bar-tabs-set (tabs &optional frame)
-  "Set a list of TABS on the FRAME."
-  (set-frame-parameter frame 'tabs tabs))
-(defcustom tab-bar-tab-face-function #'tab-bar-tab-face-default
-  "Function to define a tab face.
-Function gets one argument: a tab."
-  :type 'function
-  :group 'tab-bar
-  :version "28.1")
-(defun tab-bar-tab-face-default (tab)
-  (if (eq (car tab) 'current-tab) 'tab-bar-tab 'tab-bar-tab-inactive))
-(defcustom tab-bar-tab-name-format-function #'tab-bar-tab-name-format-default
-  "Function to format a tab name.
-Function gets two arguments, the tab and its number, and should return
-the formatted tab name to display in the tab bar."
-  :type 'function
-  :initialize 'custom-initialize-default
-  :set (lambda (sym val)
-         (set-default sym val)
-         (force-mode-line-update))
-  :group 'tab-bar
-  :version "28.1")
-(defun tab-bar-tab-name-format-default (tab i)
-  (let ((current-p (eq (car tab) 'current-tab)))
-    (propertize
-     (concat (if tab-bar-tab-hints (format "%d " i) "")
-             (alist-get 'name tab)
-             (or (and tab-bar-close-button-show
-                      (not (eq tab-bar-close-button-show
-                               (if current-p 'non-selected 'selected)))
-                      tab-bar-close-button)
-                 ""))
-     'face (funcall tab-bar-tab-face-function tab))))
-(defcustom tab-bar-format '(tab-bar-format-history
-                            tab-bar-format-tabs
-                            tab-bar-separator
-                            tab-bar-format-add-tab)
-  "Template for displaying tab bar items.
-Every item in the list is a function that returns
-a string, or a list of menu-item elements, or nil.
-Adding a function to the list causes the tab bar to show
-that string, or display a tab button which, when clicked,
-will invoke the command that is the binding of the menu item.
-The menu-item binding of nil will produce a tab clicking
-on which will select that tab.  The menu-item's title is
-displayed as the label of the tab.
-If a function returns nil, it doesn't directly affect the
-tab bar appearance, but can do that by some side-effect.
-If the list ends with `tab-bar-format-align-right' and
-`tab-bar-format-global', then after enabling `display-time-mode'
-(or any other mode that uses `global-mode-string'),
-it will display time aligned to the right on the tab bar instead
-of the mode line.  Replacing `tab-bar-format-tabs' with
-`tab-bar-format-tabs-groups' will group tabs on the tab bar."
-  :type 'hook
-  :options '(tab-bar-format-menu-bar
-             tab-bar-format-history
-             tab-bar-format-tabs
-             tab-bar-format-tabs-groups
-             tab-bar-separator
-             tab-bar-format-add-tab
-             tab-bar-format-align-right
-             tab-bar-format-global)
-  :initialize 'custom-initialize-default
-  :set (lambda (sym val)
-         (set-default sym val)
-         (force-mode-line-update))
-  :group 'tab-bar
-  :version "28.1")
-(defun tab-bar-menu-bar (event)
-  "Pop up the same menu as displayed by the menu bar.
-Used by `tab-bar-format-menu-bar'."
-  (interactive "e")
-  (let ((menu (make-sparse-keymap (propertize "Menu Bar" 'hide t))))
-    (run-hooks 'activate-menubar-hook 'menu-bar-update-hook)
-    (map-keymap (lambda (key binding)
-                  (when (consp binding)
-                    (define-key-after menu (vector key)
-                      (copy-sequence binding))))
-                (menu-bar-keymap))
-    (popup-menu menu event)))
-(defun tab-bar-format-menu-bar ()
-  "Produce the Menu button for the tab bar that shows the menu bar."
-  `((menu-bar menu-item (propertize "Menu" 'face 'tab-bar-tab-inactive)
-     tab-bar-menu-bar :help "Menu Bar")))
-(defun tab-bar-format-history ()
-  "Produce back and forward buttons for the tab bar.
-These buttons will be shown when `tab-bar-history-mode' is enabled.
-You can hide these buttons by customizing `tab-bar-format' and removing
-`tab-bar-format-history' from it."
-  (when tab-bar-history-mode
-    `((sep-history-back menu-item ,(tab-bar-separator) ignore)
-      (history-back
-       menu-item ,tab-bar-back-button tab-bar-history-back
-       :help "Click to go back in tab history")
-      (sep-history-forward menu-item ,(tab-bar-separator) ignore)
-      (history-forward
-       menu-item ,tab-bar-forward-button tab-bar-history-forward
-       :help "Click to go forward in tab history"))))
-(defun tab-bar--format-tab (tab i)
-  "Format TAB using its index I and return the result as a keymap."
-  (append
-   `((,(intern (format "sep-%i" i)) menu-item ,(tab-bar-separator) ignore))
-   (cond
-    ((eq (car tab) 'current-tab)
-     `((current-tab
-        menu-item
-        ,(funcall tab-bar-tab-name-format-function tab i)
-        ignore
-        :help "Current tab")))
-    (t
-     `((,(intern (format "tab-%i" i))
-        menu-item
-        ,(funcall tab-bar-tab-name-format-function tab i)
-        ,(alist-get 'binding tab)
-        :help "Click to visit tab"))))
-   (when (alist-get 'close-binding tab)
-     `((,(if (eq (car tab) 'current-tab) 'C-current-tab (intern (format "C-tab-%i" i)))
-        menu-item ""
-        ,(alist-get 'close-binding tab))))))
-(defun tab-bar-format-tabs ()
-  "Produce all the tabs for the tab bar."
-  (let ((i 0))
-    (mapcan
-     (lambda (tab)
-       (setq i (1+ i))
-       (tab-bar--format-tab tab i))
-     (funcall tab-bar-tabs-function))))
-(defcustom tab-bar-tab-group-function #'tab-bar-tab-group-default
-  "Function to get a tab group name.
-Function gets one argument: a tab."
-  :type 'function
-  :initialize 'custom-initialize-default
-  :set (lambda (sym val)
-         (set-default sym val)
-         (force-mode-line-update))
-  :group 'tab-bar
-  :version "28.1")
-(defun tab-bar-tab-group-default (tab)
-  (alist-get 'group tab))
-(defcustom tab-bar-tab-group-format-function #'tab-bar-tab-group-format-default
-  "Function to format a tab group name.
-Function gets two arguments, a tab with a group name and its number,
-and should return the formatted tab group name to display in the tab bar."
-  :type 'function
-  :initialize 'custom-initialize-default
-  :set (lambda (sym val)
-         (set-default sym val)
-         (force-mode-line-update))
-  :group 'tab-bar
-  :version "28.1")
-(defun tab-bar-tab-group-format-default (tab i)
-  (propertize
-   (concat (if tab-bar-tab-hints (format "%d " i) "")
-           (funcall tab-bar-tab-group-function tab))
-   'face 'tab-bar-tab-group-inactive))
-(defcustom tab-bar-tab-group-face-function #'tab-bar-tab-group-face-default
-  "Function to define a tab group face.
-Function gets one argument: a tab."
-  :type 'function
-  :group 'tab-bar
-  :version "28.1")
-(defun tab-bar-tab-group-face-default (tab)
-  (if (not (or (eq (car tab) 'current-tab)
-               (funcall tab-bar-tab-group-function tab)))
-      'tab-bar-tab-ungrouped
-    (tab-bar-tab-face-default tab)))
-(defun tab-bar--format-tab-group (tab i &optional current-p)
-  "Format TAB as a tab that represents a group of tabs.
-The argument I is the tab index, and CURRENT-P is non-nil
-when the tab is current.  Return the result as a keymap."
-  (append
-   `((,(intern (format "sep-%i" i)) menu-item ,(tab-bar-separator) ignore))
-   `((,(intern (format "group-%i" i))
-      menu-item
-      ,(if current-p
-           (propertize (funcall tab-bar-tab-group-function tab)
-                       'face 'tab-bar-tab-group-current)
-         (funcall tab-bar-tab-group-format-function tab i))
-      ,(if current-p 'ignore
-         (or
-          (alist-get 'binding tab)
-          `(lambda ()
-             (interactive)
-             (tab-bar-select-tab ,i))))
-      :help "Click to visit group"))))
-(defun tab-bar-format-tabs-groups ()
-  "Produce tabs for the tab bar grouped according to their groups."
-  (let* ((tabs (funcall tab-bar-tabs-function))
-         (current-group (funcall tab-bar-tab-group-function
-                                 (tab-bar--current-tab-find tabs)))
-         (previous-group nil)
-         (i 0))
-    (mapcan
-     (lambda (tab)
-       (let ((tab-group (funcall tab-bar-tab-group-function tab)))
-         (setq i (1+ i))
-         (prog1 (cond
-                 ;; Show current group tabs and ungrouped tabs
-                 ((or (equal tab-group current-group) (not tab-group))
-                  (append
-                   ;; Prepend current group name before first tab
-                   (when (and (not (equal previous-group tab-group)) tab-group)
-                     (tab-bar--format-tab-group tab i t))
-                   ;; Override default tab faces to use group faces
-                   (let ((tab-bar-tab-face-function tab-bar-tab-group-face-function))
-                     (tab-bar--format-tab tab i))))
-                 ;; Show first tab of other groups with a group name
-                 ((not (equal previous-group tab-group))
-                  (tab-bar--format-tab-group tab i))
-                 ;; Hide other group tabs
-                 (t nil))
-           (setq previous-group tab-group))))
-     tabs)))
-(defun tab-bar-format-add-tab ()
-  "Button to add a new tab."
-  (when (and tab-bar-new-button-show tab-bar-new-button)
-    `((add-tab menu-item ,tab-bar-new-button tab-bar-new-tab
-               :help "New tab"))))
-(defun tab-bar-format-align-right ()
-  "Align the rest of tab bar items to the right."
-  (let* ((rest (cdr (memq 'tab-bar-format-align-right tab-bar-format)))
-         (rest (tab-bar-format-list rest))
-         (rest (mapconcat (lambda (item) (nth 2 item)) rest ""))
-         (hpos (length rest))
-         (str (propertize " " 'display `(space :align-to (- right ,hpos)))))
-    `((align-right menu-item ,str ignore))))
-(defun tab-bar-format-global ()
-  "Produce display of `global-mode-string' in the tab bar.
-When `tab-bar-format-global' is added to `tab-bar-format'
-(possibly appended after `tab-bar-format-align-right'),
-then modes that display information on the mode line
-using `global-mode-string' will display the same text
-on the tab bar instead."
-  `((global menu-item ,(string-trim-right (format-mode-line global-mode-string)) ignore)))
-(defun tab-bar-format-list (format-list)
-  (let ((i 0))
-    (apply #'append
-           (mapcar
-            (lambda (format)
-              (setq i (1+ i))
-              (cond
-               ((functionp format)
-                (let ((ret (funcall format)))
-                  (when (stringp ret)
-                    (setq ret `((,(intern (format "str-%i" i))
-                                 menu-item ,ret ignore))))
-                  ret))))
-            format-list))))
-(defun tab-bar-make-keymap-1 ()
-  "Generate an actual keymap from `tab-bar-map', without caching."
-  (append tab-bar-map (tab-bar-format-list tab-bar-format)))
-;; Some window-configuration parameters don't need to be persistent.
-;; Don't save to the desktop file such tab parameters that are saved
-;; as "Unprintable entity" so can't be used after restoring the desktop.
-;; Actually tab-bar-select-tab already can handle unprintable entities,
-;; but it's better not to waste the desktop file with useless data.
-(defun frameset-filter-tabs (current _filtered _parameters saving)
-  (if saving
-      (mapcar (lambda (current)
-                (if (consp current)
-                    (seq-reduce (lambda (current param)
-                                  (assq-delete-all param current))
-                                '(wc wc-point wc-bl wc-bbl
-                                  wc-history-back wc-history-forward)
-                                (copy-sequence current))
-                  current))
-              current)
-    current))
-(push '(tabs . frameset-filter-tabs) frameset-filter-alist)
-(defun tab-bar--tab (&optional frame)
-  "Make a new tab data structure that can be added to tabs on the FRAME."
-  (let* ((tab (tab-bar--current-tab-find nil frame))
-         (tab-explicit-name (alist-get 'explicit-name tab))
-         (tab-group (alist-get 'group tab))
-         (bl  (seq-filter #'buffer-live-p (frame-parameter
-                                           frame 'buffer-list)))
-         (bbl (seq-filter #'buffer-live-p (frame-parameter
-                                           frame 'buried-buffer-list))))
-    `(tab
-      (name . ,(if tab-explicit-name
-                   (alist-get 'name tab)
-                 (funcall tab-bar-tab-name-function)))
-      (explicit-name . ,tab-explicit-name)
-      ,@(if tab-group `((group . ,tab-group)))
-      (time . ,(float-time))
-      (ws . ,(window-state-get
-              (frame-root-window (or frame (selected-frame))) 'writable))
-      (wc . ,(current-window-configuration))
-      (wc-point . ,(point-marker))
-      (wc-bl . ,bl)
-      (wc-bbl . ,bbl)
-      ,@(when tab-bar-history-mode
-          `((wc-history-back . ,(gethash (or frame (selected-frame))
-                                         tab-bar-history-back))
-            (wc-history-forward . ,(gethash (or frame (selected-frame))
-                                            tab-bar-history-forward))))
-      ;; Copy other possible parameters
-      ,@(mapcan (lambda (param)
-                  (unless (memq (car param)
-                                '(name explicit-name group time
-                                  ws wc wc-point wc-bl wc-bbl
-                                  wc-history-back wc-history-forward))
-                    (list param)))
-                (cdr tab)))))
-(defun tab-bar--current-tab (&optional tab frame)
-  "Make the current tab data structure from TAB on FRAME."
-  (tab-bar--current-tab-make (or tab (tab-bar--current-tab-find nil frame))))
-(defun tab-bar--current-tab-make (&optional tab)
-  "Make the current tab data structure from TAB.
-TAB here is an argument meaning \"use tab as template\",
-i.e. the tab is created using data from TAB.  This is
-necessary when switching tabs, otherwise the destination tab
-inherits the current tab's `explicit-name' parameter."
-  (let* ((tab-explicit-name (alist-get 'explicit-name tab))
-         (tab-group (if tab
-                        (alist-get 'group tab)
-                      (pcase tab-bar-new-tab-group
-                        ((pred stringp) tab-bar-new-tab-group)
-                        ((pred functionp) (funcall tab-bar-new-tab-group))))))
-    `(current-tab
-      (name . ,(if tab-explicit-name
-                   (alist-get 'name tab)
-                 (funcall tab-bar-tab-name-function)))
-      (explicit-name . ,tab-explicit-name)
-      ,@(if tab-group `((group . ,tab-group)))
-      ;; Copy other possible parameters
-      ,@(mapcan (lambda (param)
-                  (unless (memq (car param)
-                                '(name explicit-name group time
-                                  ws wc wc-point wc-bl wc-bbl
-                                  wc-history-back wc-history-forward))
-                    (list param)))
-                (cdr tab)))))
-(defun tab-bar--current-tab-find (&optional tabs frame)
-  ;; Find the current tab as a pointer to its data structure.
-  (assq 'current-tab (or tabs (funcall tab-bar-tabs-function frame))))
-(defun tab-bar--current-tab-index (&optional tabs frame)
-  ;; Return the index of the current tab.
-  (seq-position (or tabs (funcall tab-bar-tabs-function frame))
-                'current-tab (lambda (a b) (eq (car a) b))))
-(defun tab-bar--tab-index (tab &optional tabs frame)
-  ;; Return the index of TAB.
-  (seq-position (or tabs (funcall tab-bar-tabs-function frame))
-                tab #'eq))
-(defun tab-bar--tab-index-by-name (name &optional tabs frame)
-  ;; Return the index of TAB by the its NAME.
-  (seq-position (or tabs (funcall tab-bar-tabs-function frame))
-                name (lambda (a b) (equal (alist-get 'name a) b))))
-(defun tab-bar--tab-index-recent (nth &optional tabs frame)
-  ;; Return the index of NTH recent tab.
-  (let* ((tabs (or tabs (funcall tab-bar-tabs-function frame)))
-         (sorted-tabs (tab-bar--tabs-recent tabs frame))
-         (tab (nth (1- nth) sorted-tabs)))
-    (tab-bar--tab-index tab tabs)))
-(defun tab-bar--tabs-recent (&optional tabs frame)
-  ;; Return the list of tabs sorted by recency.
-  (let* ((tabs (or tabs (funcall tab-bar-tabs-function frame))))
-    (seq-sort-by (lambda (tab) (alist-get 'time tab)) #'>
-                 (seq-remove (lambda (tab)
-                               (eq (car tab) 'current-tab))
-                             tabs))))
-(defun tab-bar-select-tab (&optional tab-number)
-  "Switch to the tab by its absolute position TAB-NUMBER in the tab bar.
-When this command is bound to a numeric key (with a key prefix or modifier key
-using `tab-bar-select-tab-modifiers'), calling it without an argument
-will translate its bound numeric key to the numeric argument.
-Also the prefix argument TAB-NUMBER can be used to override
-the numeric key, so it takes precedence over the bound digit key.
-For example, `<MODIFIER>-2' will select the second tab, but `C-u 15
-<MODIFIER>-2' will select the 15th tab.  TAB-NUMBER counts from 1.
-Negative TAB-NUMBER counts tabs from the end of the tab bar."
-  (interactive "P")
-  (unless (integerp tab-number)
-    (let ((key (event-basic-type last-command-event)))
-      (setq tab-number (if (and (characterp key) (>= key ?1) (<= key ?9))
-                           (- key ?0)
-                         0))))
-  (let* ((tabs (funcall tab-bar-tabs-function))
-         (from-index (tab-bar--current-tab-index tabs))
-         (to-number (cond ((< tab-number 0) (+ (length tabs) (1+ tab-number)))
-                          ((zerop tab-number) (1+ from-index))
-                          (t tab-number)))
-         (to-index (1- (max 1 (min to-number (length tabs))))))
-    (unless (eq from-index to-index)
-      (let* ((from-tab (tab-bar--tab))
-             (to-tab (nth to-index tabs))
-             (wc (alist-get 'wc to-tab))
-             (ws (alist-get 'ws to-tab)))
-        ;; During the same session, use window-configuration to switch
-        ;; tabs, because window-configurations are more reliable
-        ;; (they keep references to live buffers) than window-states.
-        ;; But after restoring tabs from a previously saved session,
-        ;; its value of window-configuration is unreadable,
-        ;; so restore its saved window-state.
-        (cond
-         ((and (window-configuration-p wc)
-               ;; Check for such cases as cloning a frame with tabs.
-               ;; When tabs were cloned to another frame, then fall back
-               ;; to using `window-state-put' below.
-               (eq (window-configuration-frame wc) (selected-frame)))
-          (let ((wc-point (alist-get 'wc-point to-tab))
-                (wc-bl  (seq-filter #'buffer-live-p (alist-get 'wc-bl to-tab)))
-                (wc-bbl (seq-filter #'buffer-live-p (alist-get 'wc-bbl to-tab)))
-                (wc-history-back (alist-get 'wc-history-back to-tab))
-                (wc-history-forward (alist-get 'wc-history-forward to-tab)))
-            (set-window-configuration wc)
-            ;; set-window-configuration does not restore the value of
-            ;; point in the current buffer, so restore it separately.
-            (when (and (markerp wc-point)
-                       (marker-buffer wc-point)
-                       ;; FIXME: After dired-revert, marker relocates to 1.
-                       ;; window-configuration restores point to global point
-                       ;; in this dired buffer, not to its window point,
-                       ;; but this is slightly better than 1.
-                       ;; Maybe better to save dired-filename in each window?
-                       (not (eq 1 (marker-position wc-point))))
-              (goto-char wc-point))
-            (when wc-bl  (set-frame-parameter nil 'buffer-list wc-bl))
-            (when wc-bbl (set-frame-parameter nil 'buried-buffer-list wc-bbl))
-            (when tab-bar-history-mode
-              (puthash (selected-frame)
-                       (and (window-configuration-p (alist-get 'wc (car wc-history-back)))
-                            wc-history-back)
-                       tab-bar-history-back)
-              (puthash (selected-frame)
-                       (and (window-configuration-p (alist-get 'wc (car wc-history-forward)))
-                            wc-history-forward)
-                       tab-bar-history-forward))))
-         (ws
-          (window-state-put ws nil 'safe)))
-        (when tab-bar-history-mode
-          (setq tab-bar-history-omit t))
-        (when from-index
-          (setf (nth from-index tabs) from-tab))
-        (setf (nth to-index tabs) (tab-bar--current-tab-make (nth to-index tabs)))
-        (unless tab-bar-mode
-          (message "Selected tab '%s'" (alist-get 'name to-tab))))
-      (force-mode-line-update))))
-(defun tab-bar-switch-to-next-tab (&optional arg)
-  "Switch to ARGth next tab.
-Interactively, ARG is the prefix numeric argument and defaults to 1."
-  (interactive "p")
-  (unless (integerp arg)
-    (setq arg 1))
-  (let* ((tabs (funcall tab-bar-tabs-function))
-         (from-index (or (tab-bar--current-tab-index tabs) 0))
-         (to-index (mod (+ from-index arg) (length tabs))))
-    (tab-bar-select-tab (1+ to-index))))
-(defun tab-bar-switch-to-prev-tab (&optional arg)
-  "Switch to ARGth previous tab.
-Interactively, ARG is the prefix numeric argument and defaults to 1."
-  (interactive "p")
-  (unless (integerp arg)
-    (setq arg 1))
-  (tab-bar-switch-to-next-tab (- arg)))
-(defun tab-bar-switch-to-last-tab (&optional arg)
-  "Switch to the last tab or ARGth tab from the end of the tab bar.
-Interactively, ARG is the prefix numeric argument; it defaults to 1,
-which means the last tab on the tab bar.  For example, `C-u 2
-<MODIFIER>-9' selects the tab before the last tab."
-  (interactive "p")
-  (tab-bar-select-tab (- (length (funcall tab-bar-tabs-function))
-                         (1- (abs (or arg 1))))))
-(defun tab-bar-switch-to-recent-tab (&optional arg)
-  "Switch to ARGth most recently visited tab.
-Interactively, ARG is the prefix numeric argument and defaults to 1."
-  (interactive "p")
-  (unless (integerp arg)
-    (setq arg 1))
-  (let ((tab-index (tab-bar--tab-index-recent arg)))
-    (if tab-index
-        (tab-bar-select-tab (1+ tab-index))
-      (message "No more recent tabs"))))
-(defun tab-bar-switch-to-tab (name)
-  "Switch to the tab by NAME.
-Default values are tab names sorted by recency, so you can use \
-\\<minibuffer-local-map>\\[next-history-element]
-to get the name of the most recently visited tab, the second
-most recent, and so on.
-When the tab with that NAME doesn't exist, create a new tab
-and rename it to NAME."
-  (interactive
-   (let* ((recent-tabs (mapcar (lambda (tab)
-                                 (alist-get 'name tab))
-                               (tab-bar--tabs-recent))))
-     (list (completing-read (format-prompt "Switch to tab by name"
-                                           (car recent-tabs))
-                            recent-tabs nil nil nil nil recent-tabs))))
-  (let ((tab-index (tab-bar--tab-index-by-name name)))
-    (if tab-index
-        (tab-bar-select-tab (1+ tab-index))
-      (tab-bar-new-tab)
-      (tab-bar-rename-tab name))))
-(defalias 'tab-bar-select-tab-by-name 'tab-bar-switch-to-tab)
-(defun tab-bar-move-tab-to (to-number &optional from-number)
-  "Move tab from FROM-NUMBER position to new position at TO-NUMBER.
-FROM-NUMBER defaults to the current tab number.
-FROM-NUMBER and TO-NUMBER count from 1.
-Negative TO-NUMBER counts tabs from the end of the tab bar.
-Argument addressing is absolute in contrast to `tab-bar-move-tab'
-where argument addressing is relative."
-  (interactive "P")
-  (let* ((tabs (funcall tab-bar-tabs-function))
-         (from-number (or from-number (1+ (tab-bar--current-tab-index tabs))))
-         (from-tab (nth (1- from-number) tabs))
-         (to-number (if to-number (prefix-numeric-value to-number) 1))
-         (to-number (if (< to-number 0) (+ (length tabs) (1+ to-number)) to-number))
-         (to-index (max 0 (min (1- to-number) (1- (length tabs))))))
-    (setq tabs (delq from-tab tabs))
-    (cl-pushnew from-tab (nthcdr to-index tabs))
-    (tab-bar-tabs-set tabs)
-    (force-mode-line-update)))
-(defun tab-bar-move-tab (&optional arg)
-  "Move the current tab ARG positions to the right.
-Interactively, ARG is the prefix numeric argument and defaults to 1.
-If ARG is negative, move the current tab ARG positions to the left.
-Argument addressing is relative in contrast to `tab-bar-move-tab-to',
-where argument addressing is absolute."
-  (interactive "p")
-  (let* ((tabs (funcall tab-bar-tabs-function))
-         (from-index (or (tab-bar--current-tab-index tabs) 0))
-         (to-index (mod (+ from-index arg) (length tabs))))
-    (tab-bar-move-tab-to (1+ to-index) (1+ from-index))))
-(defun tab-bar-move-tab-backward (&optional arg)
-  "Move the current tab ARG positions to the left.
-Interactively, ARG is the prefix numeric argument and defaults to 1.
-Like `tab-bar-move-tab', but moves in the opposite direction."
-  (interactive "p")
-  (tab-bar-move-tab (- (or arg 1))))
-(defun tab-bar-move-tab-to-frame (arg &optional from-frame from-number to-frame to-number)
-  "Move tab from FROM-NUMBER position to new position at TO-NUMBER.
-FROM-NUMBER defaults to the current tab number.
-FROM-NUMBER and TO-NUMBER count from 1.
-FROM-FRAME specifies the source frame and defaults to the selected frame.
-TO-FRAME specifies the target frame and defaults the next frame.
-Interactively, ARG selects the ARGth next frame on the same terminal,
-to which to move the tab; ARG defaults to 1."
-  (interactive "P")
-  (unless from-frame
-    (setq from-frame (selected-frame)))
-  (unless to-frame
-    (dotimes (_ (prefix-numeric-value arg))
-      (setq to-frame (next-frame to-frame))))
-  (unless (eq from-frame to-frame)
-    (let* ((from-tabs (funcall tab-bar-tabs-function from-frame))
-           (from-number (or from-number (1+ (tab-bar--current-tab-index from-tabs))))
-           (from-tab (nth (1- from-number) from-tabs))
-           (to-tabs (funcall tab-bar-tabs-function to-frame))
-           (to-index (max 0 (min (1- (or to-number 1)) (1- (length to-tabs))))))
-      (cl-pushnew (assq-delete-all
-                   'wc (if (eq (car from-tab) 'current-tab)
-                           (tab-bar--tab from-frame)
-                         from-tab))
-                  (nthcdr to-index to-tabs))
-      (with-selected-frame from-frame
-        (let ((inhibit-message t) ; avoid message about deleted tab
-              (tab-bar-close-last-tab-choice 'delete-frame)
-              tab-bar-closed-tabs)
-          (tab-bar-close-tab from-number)))
-      (tab-bar-tabs-set to-tabs to-frame)
-      (force-mode-line-update t))))
-(defun tab-bar-detach-tab (&optional from-number)
-  "Move tab number FROM-NUMBER to a new frame.
-FROM-NUMBER defaults to the current tab (which happens interactively)."
-  (interactive (list (1+ (tab-bar--current-tab-index))))
-  (let* ((tabs (funcall tab-bar-tabs-function))
-         (tab-index (1- (or from-number (1+ (tab-bar--current-tab-index tabs)))))
-         (tab-name (alist-get 'name (nth tab-index tabs)))
-         ;; On some window managers, `make-frame' selects the new frame,
-         ;; so previously selected frame is saved to `from-frame'.
-         (from-frame (selected-frame))
-         (new-frame (make-frame `((name . ,tab-name)))))
-    (tab-bar-move-tab-to-frame nil from-frame from-number new-frame nil)
-    (with-selected-frame new-frame
-      (tab-bar-close-tab))))
-(defun tab-bar-move-window-to-tab ()
-  "Move the selected window to a new tab.
-This command removes the selected window from the configuration stored
-on the current tab, and makes a new tab with that window in its
-configuration."
-  (interactive)
-  (let ((tab-bar-new-tab-choice 'window))
-    (tab-bar-new-tab))
-  (tab-bar-switch-to-recent-tab)
-  (delete-window)
-  (tab-bar-switch-to-recent-tab))
-(defcustom tab-bar-new-tab-to 'right
-  "Where to create a new tab.
-If `leftmost', create as the first tab.
-If `left', create to the left of the current tab.
-If `right', create to the right of the current tab.
-If `rightmost', create as the last tab.
-If the value is a function, it should return a number as a position
-on the tab bar specifying where to add a new tab."
-  :type '(choice (const :tag "Add as First" leftmost)
-                 (const :tag "Add to Left" left)
-                 (const :tag "Add to Right" right)
-                 (const :tag "Add as Last" rightmost)
-                 (function :tag "Function"))
-  :group 'tab-bar
-  :version "27.1")
-(defcustom tab-bar-tab-post-open-functions nil
-  "List of functions to call after creating a new tab.
-The current tab is supplied as an argument.  Any modifications made
-to the tab argument will be applied after all functions are called."
-  :type '(repeat function)
-  :group 'tab-bar
-  :version "27.1")
-(defun tab-bar-new-tab-to (&optional tab-number)
-  "Add a new tab at the absolute position TAB-NUMBER.
-TAB-NUMBER counts from 1.  If no TAB-NUMBER is specified, then add
-a new tab at the position specified by `tab-bar-new-tab-to'.
-Negative TAB-NUMBER counts tabs from the end of the tab bar,
-and -1 means the new tab will become the last one.
-Argument addressing is absolute in contrast to `tab-bar-new-tab',
-where argument addressing is relative.
-After the tab is created, the hooks in
-`tab-bar-tab-post-open-functions' are run."
-  (interactive "P")
-  (let* ((tabs (funcall tab-bar-tabs-function))
-         (from-index (tab-bar--current-tab-index tabs))
-         (from-tab (tab-bar--tab)))
-    (when tab-bar-new-tab-choice
-      ;; Handle the case when it's called in the active minibuffer.
-      (when (minibuffer-selected-window)
-        (select-window (minibuffer-selected-window)))
-      (let ((ignore-window-parameters t))
-        (delete-other-windows))
-      (unless (eq tab-bar-new-tab-choice 'window)
-        ;; Create a new window to get rid of old window parameters
-        ;; (e.g. prev/next buffers) of old window.
-        (split-window) (delete-window))
-      (let ((buffer
-             (if (functionp tab-bar-new-tab-choice)
-                 (funcall tab-bar-new-tab-choice)
-               (if (stringp tab-bar-new-tab-choice)
-                   (or (get-buffer tab-bar-new-tab-choice)
-                       (find-file-noselect tab-bar-new-tab-choice))))))
-        (when (buffer-live-p buffer)
-          (switch-to-buffer buffer))))
-    (when from-index
-      (setf (nth from-index tabs) from-tab))
-    (let* ((to-tab (tab-bar--current-tab-make
-                    (when (eq tab-bar-new-tab-group t)
-                      `((group . ,(alist-get 'group from-tab))))))
-           (to-number (and tab-number (prefix-numeric-value tab-number)))
-           (to-index (or (if to-number
-                             (if (< to-number 0)
-                                 (+ (length tabs) (1+ to-number))
-                               (1- to-number)))
-                         (pcase tab-bar-new-tab-to
-                           ('leftmost 0)
-                           ('rightmost (length tabs))
-                           ('left (or from-index 1))
-                           ('right (1+ (or from-index 0)))
-                           ((pred functionp)
-                            (funcall tab-bar-new-tab-to))))))
-      (setq to-index (max 0 (min (or to-index 0) (length tabs))))
-      (cl-pushnew to-tab (nthcdr to-index tabs))
-      (when (eq to-index 0)
-        ;; `pushnew' handles the head of tabs but not frame-parameter
-        (tab-bar-tabs-set tabs))
-      (when tab-bar-history-mode
-        (puthash (selected-frame) nil tab-bar-history-back)
-        (puthash (selected-frame) nil tab-bar-history-forward)
-        (setq tab-bar-history-omit t))
-      (run-hook-with-args 'tab-bar-tab-post-open-functions
-                          (nth to-index tabs)))
-    (when tab-bar-show
-      (if (not tab-bar-mode)
-          ;; Turn on `tab-bar-mode' since a tab was created.
-          ;; Note: this also updates `tab-bar-lines'.
-          (tab-bar-mode 1)
-        (tab-bar--update-tab-bar-lines)))
-    (force-mode-line-update)
-    (unless tab-bar-mode
-      (message "Added new tab at %s" tab-bar-new-tab-to))))
-(defun tab-bar-new-tab (&optional arg from-number)
-  "Create a new tab ARG positions to the right.
-If a negative ARG, create a new tab ARG positions to the left.
-If ARG is zero, create a new tab in place of the current tab.
-If no ARG is specified, then add a new tab at the position
-specified by `tab-bar-new-tab-to'.
-Argument addressing is relative in contrast to `tab-bar-new-tab-to',
-where argument addressing is absolute.
-If FROM-NUMBER is a tab number, a new tab is created from that tab."
-  (interactive "P")
-  (when from-number
-    (let ((inhibit-message t))
-      (tab-bar-select-tab from-number)))
-  (if arg
-      (let* ((tabs (funcall tab-bar-tabs-function))
-             (from-index (or (tab-bar--current-tab-index tabs) 0))
-             (to-index (+ from-index (prefix-numeric-value arg))))
-        (tab-bar-new-tab-to (1+ to-index)))
-    (tab-bar-new-tab-to)))
-(defun tab-bar-duplicate-tab (&optional arg from-number)
-  "Clone the current tab to ARG positions to the right.
-ARG and FROM-NUMBER have the same meaning as in `tab-bar-new-tab'."
-  (interactive "P")
-  (let ((tab-bar-new-tab-choice nil)
-        (tab-bar-new-tab-group t))
-    (tab-bar-new-tab arg from-number)))
-(defvar tab-bar-closed-tabs nil
-  "A list of closed tabs to be able to undo their closing.")
-(defcustom tab-bar-close-tab-select 'recent
-  "Which tab to make current after closing the specified tab.
-If `left', select the adjacent left tab.
-If `right', select the adjacent right tab.
-If `recent', select the most recently visited tab."
-  :type '(choice (const :tag "Select left tab" left)
-                 (const :tag "Select right tab" right)
-                 (const :tag "Select recent tab" recent))
-  :group 'tab-bar
-  :version "27.1")
-(defcustom tab-bar-close-last-tab-choice nil
-  "What to do when the last tab is closed.
-If nil, do nothing and show a message, like closing the last window or frame.
-If `delete-frame', delete the containing frame, as a web browser would do.
-If `tab-bar-mode-disable', disable `tab-bar-mode' so that tabs no longer show
-in the frame.
-If the value is a function, call that function with the tab to be closed
-as an argument."
-  :type '(choice (const    :tag "Do nothing and show message" nil)
-                 (const    :tag "Close the containing frame" delete-frame)
-                 (const    :tag "Disable tab-bar-mode" tab-bar-mode-disable)
-                 (function :tag "Function"))
-  :group 'tab-bar
-  :version "27.1")
-(defcustom tab-bar-tab-prevent-close-functions nil
-  "List of functions to call to determine whether to close a tab.
-The tab to be closed and a boolean indicating whether or not it
-is the only tab in the frame are supplied as arguments.  If any
-function returns a non-nil value, the tab will not be closed."
-  :type '(repeat function)
-  :group 'tab-bar
-  :version "27.1")
-(defcustom tab-bar-tab-pre-close-functions nil
-  "List of functions to call before closing a tab.
-Each function is called with two arguments: the tab to be closed
-and a boolean indicating whether or not it is the only tab on its frame."
-  :type '(repeat function)
-  :group 'tab-bar
-  :version "27.1")
-(defun tab-bar-close-tab (&optional tab-number to-number)
-  "Close the tab specified by its absolute position TAB-NUMBER.
-If no TAB-NUMBER is specified, then close the current tab and switch
-to the tab specified by `tab-bar-close-tab-select'.
-Interactively, TAB-NUMBER is the prefix numeric argument, and defaults to 1.
-TAB-NUMBER counts from 1.
-Optional TO-NUMBER could be specified to override the value of
-`tab-bar-close-tab-select' programmatically with a position
-of an existing tab to select after closing the current tab.
-TO-NUMBER counts from 1.
-The functions in `tab-bar-tab-prevent-close-functions' will be
-run to determine whether or not to close the tab.
-Just before the tab is closed, the functions in
-`tab-bar-tab-pre-close-functions' will be run.  The base behavior
-for the last tab on a frame is determined by
-`tab-bar-close-last-tab-choice'."
-  (interactive "P")
-  (let* ((tabs (funcall tab-bar-tabs-function))
-         (current-index (tab-bar--current-tab-index tabs))
-         (close-index (if (integerp tab-number) (1- tab-number) current-index))
-         (last-tab-p (= 1 (length tabs)))
-         (prevent-close (run-hook-with-args-until-success
-                         'tab-bar-tab-prevent-close-functions
-                         (nth close-index tabs)
-                         last-tab-p)))
-    (unless prevent-close
-      (run-hook-with-args 'tab-bar-tab-pre-close-functions
-                          (nth close-index tabs)
-                          last-tab-p)
-      (if last-tab-p
-          (pcase tab-bar-close-last-tab-choice
-            ('nil
-             (user-error "Attempt to delete the sole tab in a frame"))
-            ('delete-frame
-             (delete-frame))
-            ('tab-bar-mode-disable
-             (tab-bar-mode -1))
-            ((pred functionp)
-             ;; Give the handler function the full extent of the tab's
-             ;; data, not just it's name and explicit-name flag.
-             (funcall tab-bar-close-last-tab-choice (tab-bar--tab))))
-        ;; More than one tab still open
-        (when (eq current-index close-index)
-          ;; Select another tab before deleting the current tab
-          (let ((to-index (or (if to-number (1- to-number))
-                              (pcase tab-bar-close-tab-select
-                                ('left (1- (if (< current-index 1) 2 current-index)))
-                                ('right (if (> (length tabs) (1+ current-index))
-                                            (1+ current-index)
-                                          (1- current-index)))
-                                ('recent (tab-bar--tab-index-recent 1 tabs))))))
-            (setq to-index (max 0 (min (or to-index 0) (1- (length tabs)))))
-            (let ((inhibit-message t)) ; avoid message about selected tab
-              (tab-bar-select-tab (1+ to-index)))
-            ;; Re-read tabs after selecting another tab
-            (setq tabs (funcall tab-bar-tabs-function))))
-        (let ((close-tab (nth close-index tabs)))
-          (push `((frame . ,(selected-frame))
-                  (index . ,close-index)
-                  (tab . ,(if (eq (car close-tab) 'current-tab)
-                              (tab-bar--tab)
-                            close-tab)))
-                tab-bar-closed-tabs)
-          (tab-bar-tabs-set (delq close-tab tabs)))
-        ;; Recalculate `tab-bar-lines' and update frames
-        (tab-bar--update-tab-bar-lines)
-        (force-mode-line-update)
-        (unless tab-bar-mode
-          (message "Deleted tab and switched to %s" tab-bar-close-tab-select))))))
-(defun tab-bar-close-tab-by-name (name)
-  "Close the tab given its NAME.
-Interactively, prompt for NAME."
-  (interactive
-   (list (completing-read "Close tab by name: "
-                          (mapcar (lambda (tab)
-                                    (alist-get 'name tab))
-                                  (funcall tab-bar-tabs-function)))))
-  (tab-bar-close-tab (1+ (tab-bar--tab-index-by-name name))))
-(defun tab-bar-close-other-tabs (&optional tab-number)
-  "Close all tabs on the selected frame, except the tab TAB-NUMBER.
-TAB-NUMBER counts from 1 and defaults to the current tab (which
-happens interactively)."
-  (interactive)
-  (let* ((tabs (funcall tab-bar-tabs-function))
-         (current-index (tab-bar--current-tab-index tabs))
-         (keep-index (if (integerp tab-number)
-                         (1- (max 1 (min tab-number (length tabs))))
-                       current-index))
-         (index 0))
-    (when (nth keep-index tabs)
-      (unless (eq keep-index current-index)
-        (tab-bar-select-tab (1+ keep-index))
-        (setq tabs (funcall tab-bar-tabs-function)))
-      (dolist (tab tabs)
-        (unless (or (eq index keep-index)
-                    (run-hook-with-args-until-success
-                     'tab-bar-tab-prevent-close-functions tab
-                     ;; `last-tab-p' logically can't ever be true
-                     ;; if we make it this far
-                     nil))
-          (push `((frame . ,(selected-frame))
-                  (index . ,index)
-                  (tab . ,tab))
-                tab-bar-closed-tabs)
-          (run-hook-with-args 'tab-bar-tab-pre-close-functions tab nil)
-          (setq tabs (delq tab tabs)))
-        (setq index (1+ index)))
-      (tab-bar-tabs-set tabs)
-      ;; Recalculate tab-bar-lines and update frames
-      (tab-bar--update-tab-bar-lines)
-      (force-mode-line-update)
-      (unless tab-bar-mode
-        (message "Deleted all other tabs")))))
-(defun tab-bar-undo-close-tab ()
-  "Restore the most recently closed tab."
-  (interactive)
-  ;; Pop out closed tabs that were on already deleted frames
-  (while (and tab-bar-closed-tabs
-              (not (frame-live-p (alist-get 'frame (car tab-bar-closed-tabs)))))
-    (pop tab-bar-closed-tabs))
-  (if tab-bar-closed-tabs
-      (let* ((closed (pop tab-bar-closed-tabs))
-             (frame (alist-get 'frame closed))
-             (index (alist-get 'index closed))
-             (tab (alist-get 'tab closed)))
-        (unless (eq frame (selected-frame))
-          (select-frame-set-input-focus frame))
-        (let ((tabs (funcall tab-bar-tabs-function)))
-          (setq index (max 0 (min index (length tabs))))
-          (cl-pushnew tab (nthcdr index tabs))
-          (when (eq index 0)
-            ;; pushnew handles the head of tabs but not frame-parameter
-            (tab-bar-tabs-set tabs))
-          (tab-bar-select-tab (1+ index))))
-    (message "No more closed tabs to undo")))
-(defun tab-bar-rename-tab (name &optional tab-number)
-  "Give the tab specified by its absolute position TAB-NUMBER a new NAME.
-If no TAB-NUMBER is specified, then rename the current tab.
-Interactively, TAB-NUMBER is the prefix numeric argument, and defaults
-to the current tab.
-TAB-NUMBER counts from 1.
-Interactively, prompt for the new NAME.
-If NAME is the empty string, then use the automatic name
-function `tab-bar-tab-name-function'."
-  (interactive
-   (let* ((tabs (funcall tab-bar-tabs-function))
-          (tab-number (or current-prefix-arg (1+ (tab-bar--current-tab-index tabs))))
-          (tab-name (alist-get 'name (nth (1- tab-number) tabs))))
-     (list (read-from-minibuffer
-            "New name for tab (leave blank for automatic naming): "
-            nil nil nil nil tab-name)
-           current-prefix-arg)))
-  (let* ((tabs (funcall tab-bar-tabs-function))
-         (tab-index (if (integerp tab-number)
-                        (1- (max 0 (min tab-number (length tabs))))
-                      (tab-bar--current-tab-index tabs)))
-         (tab-to-rename (nth tab-index tabs))
-         (tab-explicit-name (> (length name) 0))
-         (tab-new-name (if tab-explicit-name
-                           name
-                         (funcall tab-bar-tab-name-function))))
-    (setf (alist-get 'name tab-to-rename) tab-new-name
-          (alist-get 'explicit-name tab-to-rename) tab-explicit-name)
-    (force-mode-line-update)
-    (unless tab-bar-mode
-      (message "Renamed tab to '%s'" tab-new-name))))
-(defun tab-bar-rename-tab-by-name (tab-name new-name)
-  "Rename the tab named TAB-NAME to NEW-NAME.
-Interactively, prompt for TAB-NAME and NEW-NAME.
-If NEW-NAME is the empty string, then use the automatic name
-function `tab-bar-tab-name-function'."
-  (interactive
-   (let ((tab-name (completing-read "Rename tab by name: "
-                                    (mapcar (lambda (tab)
-                                              (alist-get 'name tab))
-                                            (funcall tab-bar-tabs-function)))))
-     (list tab-name (read-from-minibuffer
-                     "New name for tab (leave blank for automatic naming): "
-                     nil nil nil nil tab-name))))
-  (tab-bar-rename-tab new-name (1+ (tab-bar--tab-index-by-name tab-name))))
-;;; Tab groups
-(defun tab-bar-move-tab-to-group (&optional tab)
-  "Relocate TAB (by default, the current tab) closer to its group."
-  (interactive)
-  (let* ((tabs (funcall tab-bar-tabs-function))
-         (tab (or tab (tab-bar--current-tab-find tabs)))
-         (tab-index (tab-bar--tab-index tab))
-         (group (alist-get 'group tab))
-         ;; Beginning position of the same group
-         (beg (seq-position tabs group
-                            (lambda (tb gr)
-                              (and (not (eq tb tab))
-                                   (equal (alist-get 'group tb) gr)))))
-         ;; Size of the same group
-         (len (when beg
-                (seq-position (nthcdr beg tabs) group
-                              (lambda (tb gr)
-                                (not (equal (alist-get 'group tb) gr))))))
-         (pos (when beg
-                (cond
-                 ;; Don't move tab when it's already inside group bounds
-                 ((and len (>= tab-index beg) (<= tab-index (+ beg len))) nil)
-                 ;; Move tab from the right to the group end
-                 ((and len (> tab-index (+ beg len))) (+ beg len 1))
-                 ;; Move tab from the left to the group beginning
-                 ((< tab-index beg) beg)))))
-    (when pos
-      (tab-bar-move-tab-to pos (1+ tab-index)))))
-(defcustom tab-bar-tab-post-change-group-functions nil
-  "List of functions to call after changing a tab group.
-The current tab is supplied as an argument."
-  :type 'hook
-  :options '(tab-bar-move-tab-to-group)
-  :group 'tab-bar
-  :version "28.1")
-(defun tab-bar-change-tab-group (group-name &optional tab-number)
-  "Add the tab specified by its absolute position TAB-NUMBER to GROUP-NAME.
-If no TAB-NUMBER is specified, then set the GROUP-NAME for the current tab.
-Interactively, TAB-NUMBER is the prefix numeric argument, and the command
-prompts for GROUP-NAME.
-TAB-NUMBER counts from 1.
-If GROUP-NAME is the empty string, then remove the tab from any group.
-While using this command, you might also want to replace
-`tab-bar-format-tabs' with `tab-bar-format-tabs-groups' in
-`tab-bar-format' to group tabs on the tab bar."
-  (interactive
-   (let* ((tabs (funcall tab-bar-tabs-function))
-          (tab-number (or current-prefix-arg
-                         (1+ (tab-bar--current-tab-index tabs))))
-          (group-name (funcall tab-bar-tab-group-function
-                               (nth (1- tab-number) tabs))))
-     (list (completing-read
-            "Group name for tab (leave blank to remove group): "
-            (delete-dups
-             (delq nil (cons group-name
-                             (mapcar (lambda (tab)
-                                       (funcall tab-bar-tab-group-function tab))
-                                     (funcall tab-bar-tabs-function))))))
-           current-prefix-arg)))
-  (let* ((tabs (funcall tab-bar-tabs-function))
-         (tab-index (if tab-number
-                        (1- (max 0 (min tab-number (length tabs))))
-                      (tab-bar--current-tab-index tabs)))
-         (tab (nth tab-index tabs))
-         (group (assq 'group tab))
-         (group-new-name (and (> (length group-name) 0) group-name)))
-    (if group
-        (setcdr group group-new-name)
-      (nconc tab `((group . ,group-new-name))))
-    (run-hook-with-args 'tab-bar-tab-post-change-group-functions tab)
-    (force-mode-line-update)
-    (unless tab-bar-mode
-      (message "Set tab group to '%s'" group-new-name))))
-(defun tab-bar-close-group-tabs (group-name)
-  "Close all tabs that belong to GROUP-NAME on the selected frame.
-Interactively, prompt for GROUP-NAME."
-  (interactive
-   (let ((group-name (funcall tab-bar-tab-group-function
-                              (tab-bar--current-tab-find))))
-     (list (completing-read
-            "Close all tabs with group name: "
-            (delete-dups
-             (delq nil (cons group-name
-                             (mapcar (lambda (tab)
-                                       (funcall tab-bar-tab-group-function tab))
-                                     (funcall tab-bar-tabs-function)))))))))
-  (let* ((close-group (and (> (length group-name) 0) group-name))
-         (tab-bar-tab-prevent-close-functions
-          (cons (lambda (tab _last-tab-p)
-                  (not (equal (funcall tab-bar-tab-group-function tab)
-                              close-group)))
-                tab-bar-tab-prevent-close-functions)))
-    (tab-bar-close-other-tabs)
-    (when (equal (funcall tab-bar-tab-group-function
-                          (tab-bar--current-tab-find))
-                 close-group)
-      (tab-bar-close-tab))))
-;;; Tab history mode
-(defvar tab-bar-history-limit 10
-  "The number of history elements to keep.")
-(defvar tab-bar-history-omit nil
-  "When non-nil, omit window-configuration changes from the current command.")
-(defvar tab-bar-history-back (make-hash-table)
-  "History of back changes in every tab per frame.")
-(defvar tab-bar-history-forward (make-hash-table)
-  "History of forward changes in every tab per frame.")
-(defvar tab-bar-history-old nil
-  "Window configuration before the current command.")
-(defvar tab-bar-history-pre-command nil
-  "Command set to `this-command' by `pre-command-hook'.")
-(defvar tab-bar-history-done-command nil
-  "Command handled by `window-configuration-change-hook'.")
-(defun tab-bar--history-pre-change ()
-  ;; Reset before the command could set it
-  (setq tab-bar-history-omit nil)
-  (setq tab-bar-history-pre-command this-command)
-  (when (zerop (minibuffer-depth))
-    (setq tab-bar-history-old
-          `((wc . ,(current-window-configuration))
-            (wc-point . ,(point-marker))))))
-(defun tab-bar--history-change ()
-  (when (and (not tab-bar-history-omit) tab-bar-history-old
-             ;; Don't register changes performed by the same command
-             ;; repeated in sequence, such as incremental window resizing.
-             (not (eq tab-bar-history-done-command tab-bar-history-pre-command))
-             (zerop (minibuffer-depth)))
-    (puthash (selected-frame)
-             (seq-take (cons tab-bar-history-old
-                             (gethash (selected-frame) tab-bar-history-back))
-                       tab-bar-history-limit)
-             tab-bar-history-back)
-    (setq tab-bar-history-old nil))
-  (setq tab-bar-history-done-command tab-bar-history-pre-command))
-(defun tab-bar-history-back ()
-  "Restore a previous window configuration used in the current tab.
-This navigates back in the history of window configurations."
-  (interactive)
-  (setq tab-bar-history-omit t)
-  (let* ((history (pop (gethash (selected-frame) tab-bar-history-back)))
-         (wc (alist-get 'wc history))
-         (wc-point (alist-get 'wc-point history)))
-    (if (window-configuration-p wc)
-        (progn
-          (puthash (selected-frame)
-                   (cons tab-bar-history-old
-                         (gethash (selected-frame) tab-bar-history-forward))
-                   tab-bar-history-forward)
-          (set-window-configuration wc)
-          (when (and (markerp wc-point) (marker-buffer wc-point))
-            (goto-char wc-point)))
-      (message "No more tab back history"))))
-(defun tab-bar-history-forward ()
-  "Cancel restoration of the previous window configuration.
-This navigates forward in the history of window configurations."
-  (interactive)
-  (setq tab-bar-history-omit t)
-  (let* ((history (pop (gethash (selected-frame) tab-bar-history-forward)))
-         (wc (alist-get 'wc history))
-         (wc-point (alist-get 'wc-point history)))
-    (if (window-configuration-p wc)
-        (progn
-          (puthash (selected-frame)
-                   (cons tab-bar-history-old
-                         (gethash (selected-frame) tab-bar-history-back))
-                   tab-bar-history-back)
-          (set-window-configuration wc)
-          (when (and (markerp wc-point) (marker-buffer wc-point))
-            (goto-char wc-point)))
-      (message "No more tab forward history"))))
-(defvar-keymap tab-bar-history-mode-map
-  "C-c <left>"  #'tab-bar-history-back
-  "C-c <right>" #'tab-bar-history-forward)
-(define-minor-mode tab-bar-history-mode
-  "Toggle tab history mode for the tab bar.
-Tab history mode remembers window configurations used in every tab,
-and can restore them."
-  :global t :group 'tab-bar
-  (if tab-bar-history-mode
-      (progn
-        (when (and tab-bar-mode (not (get-text-property 0 'display tab-bar-back-button)))
-          ;; This file is pre-loaded so only here we can use the right data-directory:
-          (add-text-properties 0 (length tab-bar-back-button)
-                               `(display (image :type xpm
-                                                :file "tabs/left-arrow.xpm"
-                                                :margin ,tab-bar-button-margin
-                                                :ascent center))
-                               tab-bar-back-button))
-        (when (and tab-bar-mode (not (get-text-property 0 'display tab-bar-forward-button)))
-          ;; This file is pre-loaded so only here we can use the right data-directory:
-          (add-text-properties 0 (length tab-bar-forward-button)
-                               `(display (image :type xpm
-                                                :file "tabs/right-arrow.xpm"
-                                                :margin ,tab-bar-button-margin
-                                                :ascent center))
-                               tab-bar-forward-button))
-        (add-hook 'pre-command-hook 'tab-bar--history-pre-change)
-        (add-hook 'window-configuration-change-hook 'tab-bar--history-change))
-    (remove-hook 'pre-command-hook 'tab-bar--history-pre-change)
-    (remove-hook 'window-configuration-change-hook 'tab-bar--history-change)))
-;;; Non-graphical access to frame-local tabs (named window configurations)
-(defun tab-switcher ()
-  "Display a list of named window configurations.
-The list is displayed in the buffer `*Tabs*'.
-It's placed in the center of the frame to resemble a window list
-displayed by a window switcher in some window managers on Alt+Tab.
-In this list of window configurations you can delete or select them.
-Type ? after invocation to get help on commands available.
-Type q to remove the list of window configurations from the display.
-The first column shows `D' for a window configuration you have
-marked for deletion."
-  (interactive)
-  (let ((dir default-directory))
-    (let ((tab-bar-new-tab-choice t)
-          ;; Don't enable tab-bar-mode if it's disabled
-          (tab-bar-show nil))
-      (tab-bar-new-tab))
-    (let ((switch-to-buffer-preserve-window-point nil))
-      (switch-to-buffer (tab-switcher-noselect)))
-    (setq default-directory dir))
-  (message "Commands: d, x; RET; q to quit; ? for help."))
-(defun tab-switcher-noselect ()
-  "Create and return a buffer with a list of window configurations.
-The list is displayed in a buffer named `*Tabs*'.
-For more information, see the function `tab-switcher'."
-  (let* ((tabs (seq-remove (lambda (tab)
-                             (eq (car tab) 'current-tab))
-                           (funcall tab-bar-tabs-function)))
-         ;; Sort by recency
-         (tabs (sort tabs (lambda (a b) (< (alist-get 'time b)
-                                           (alist-get 'time a))))))
-    (with-current-buffer (get-buffer-create
-                          (format " *Tabs*<%s>" (or (frame-parameter nil 'window-id)
-                                                    (frame-parameter nil 'name))))
-      (setq buffer-read-only nil)
-      (erase-buffer)
-      (tab-switcher-mode)
-      ;; Vertical alignment to the center of the frame
-      (insert-char ?\n (/ (- (frame-height) (length tabs) 1) 2))
-      ;; Horizontal alignment to the center of the frame
-      (setq tab-switcher-column (- (/ (frame-width) 2) 15))
-      (dolist (tab tabs)
-        (insert (propertize
-                 (format "%s %s\n"
-                         (make-string tab-switcher-column ?\040)
-                         (propertize
-                          (alist-get 'name tab)
-                          'mouse-face 'highlight
-                          'help-echo "mouse-2: select this window configuration"))
-                 'tab tab)))
-      (goto-char (point-min))
-      (goto-char (or (next-single-property-change (point) 'tab) (point-min)))
-      (when (> (length tabs) 1)
-        (tab-switcher-next-line))
-      (move-to-column tab-switcher-column)
-      (set-buffer-modified-p nil)
-      (setq buffer-read-only t)
-      (current-buffer))))
-(defvar-local tab-switcher-column 3)
-(defvar tab-switcher-mode-map
-  (let ((map (make-keymap)))
-    (suppress-keymap map t)
-    (define-key map "q"    'quit-window)
-    (define-key map "\C-m" 'tab-switcher-select)
-    (define-key map "d"    'tab-switcher-delete)
-    (define-key map "k"    'tab-switcher-delete)
-    (define-key map "\C-d" 'tab-switcher-delete-backwards)
-    (define-key map "\C-k" 'tab-switcher-delete)
-    (define-key map "x"    'tab-switcher-execute)
-    (define-key map " "    'tab-switcher-next-line)
-    (define-key map "n"    'tab-switcher-next-line)
-    (define-key map "p"    'tab-switcher-prev-line)
-    (define-key map "\177" 'tab-switcher-backup-unmark)
-    (define-key map "?"    'describe-mode)
-    (define-key map "u"    'tab-switcher-unmark)
-    (define-key map [mouse-2] 'tab-switcher-mouse-select)
-    (define-key map [follow-link] 'mouse-face)
-    map)
-  "Local keymap for `tab-switcher-mode' buffers.")
-(define-derived-mode tab-switcher-mode nil "Window Configurations"
-  "Major mode for selecting a window configuration.
-Each line describes one window configuration in Emacs.
-Letters do not insert themselves; instead, they are commands.
-\\<tab-switcher-mode-map>
-\\[tab-switcher-mouse-select] -- select window configuration you click on.
-\\[tab-switcher-select] -- select current line's window configuration.
-\\[tab-switcher-delete] -- mark that window configuration to be deleted, and move down.
-\\[tab-switcher-delete-backwards] -- mark that window configuration to be deleted, and move up.
-\\[tab-switcher-execute] -- delete marked window configurations.
-\\[tab-switcher-unmark] -- remove all kinds of marks from current line.
-  With prefix argument, also move up one line.
-\\[tab-switcher-backup-unmark] -- back up a line and remove marks."
-  (setq truncate-lines t))
-(defun tab-switcher-current-tab (error-if-non-existent-p)
-  "Return window configuration described by this line of the list."
-  (let* ((where (save-excursion
-                  (beginning-of-line)
-                  (+ 2 (point) tab-switcher-column)))
-         (tab (and (not (eobp)) (get-text-property where 'tab))))
-    (or tab
-        (if error-if-non-existent-p
-            (user-error "No window configuration on this line")
-          nil))))
-(defun tab-switcher-next-line (&optional arg)
-  "Move to ARGth next line in the list of tabs.
-Interactively, ARG is the prefix numeric argument and defaults to 1."
-  (interactive "p")
-  (forward-line arg)
-  (beginning-of-line)
-  (move-to-column tab-switcher-column))
-(defun tab-switcher-prev-line (&optional arg)
-  "Move to ARGth previous line in the list of tabs.
-Interactively, ARG is the prefix numeric argument and defaults to 1."
-  (interactive "p")
-  (forward-line (- arg))
-  (beginning-of-line)
-  (move-to-column tab-switcher-column))
-(defun tab-switcher-unmark (&optional backup)
-  "Cancel requested operations on window configuration on this line and move down.
-With prefix arg, move up instead."
-  (interactive "P")
-  (beginning-of-line)
-  (move-to-column tab-switcher-column)
-  (let* ((buffer-read-only nil))
-    (delete-char 1)
-    (insert " "))
-  (forward-line (if backup -1 1))
-  (move-to-column tab-switcher-column))
-(defun tab-switcher-backup-unmark ()
-  "Move up one line and cancel requested operations on window configuration there."
-  (interactive)
-  (forward-line -1)
-  (tab-switcher-unmark)
-  (forward-line -1)
-  (move-to-column tab-switcher-column))
-(defun tab-switcher-delete (&optional arg)
-  "Mark window configuration on this line to be deleted by \\<tab-switcher-mode-map>\\[tab-switcher-execute] command.
-Prefix arg says how many window configurations to delete.
-Negative arg means delete backwards."
-  (interactive "p")
-  (let ((buffer-read-only nil))
-    (if (or (null arg) (= arg 0))
-        (setq arg 1))
-    (while (> arg 0)
-      (delete-char 1)
-      (insert ?D)
-      (forward-line 1)
-      (setq arg (1- arg)))
-    (while (< arg 0)
-      (delete-char 1)
-      (insert ?D)
-      (forward-line -1)
-      (setq arg (1+ arg)))
-    (move-to-column tab-switcher-column)))
-(defun tab-switcher-delete-backwards (&optional arg)
-  "Mark window configuration on this line to be deleted by \\<tab-switcher-mode-map>\\[tab-switcher-execute] command.
-Then move up one line.  Prefix arg means move that many lines."
-  (interactive "p")
-  (tab-switcher-delete (- (or arg 1))))
-(defun tab-switcher-delete-from-list (tab)
-  "Delete the window configuration from the list of tabs."
-  (push `((frame . ,(selected-frame))
-          (index . ,(tab-bar--tab-index tab))
-          (tab . ,tab))
-        tab-bar-closed-tabs)
-  (tab-bar-tabs-set (delq tab (funcall tab-bar-tabs-function))))
-(defun tab-switcher-execute ()
-  "Delete window configurations marked with \\<tab-switcher-mode-map>\\[tab-switcher-delete] commands."
-  (interactive)
-  (save-excursion
-    (goto-char (point-min))
-    (let ((buffer-read-only nil))
-      (while (re-search-forward
-              (format "^%sD" (make-string tab-switcher-column ?\040))
-              nil t)
-        (forward-char -1)
-        (let ((tab (tab-switcher-current-tab nil)))
-          (when tab
-            (tab-switcher-delete-from-list tab)
-            (beginning-of-line)
-            (delete-region (point) (progn (forward-line 1) (point))))))))
-  (beginning-of-line)
-  (move-to-column tab-switcher-column)
-  (force-mode-line-update))
-(defun tab-switcher-select ()
-  "Select this line's window configuration.
-This command replaces all the existing windows in the selected frame
-with those specified by the selected window configuration."
-  (interactive)
-  (let* ((to-tab (tab-switcher-current-tab t)))
-    (kill-buffer (current-buffer))
-    ;; Delete the current window configuration of tab list
-    ;; without storing it in the undo list of closed tabs
-    (let ((inhibit-message t) ; avoid message about deleted tab
-          tab-bar-closed-tabs)
-      (tab-bar-close-tab nil (1+ (tab-bar--tab-index to-tab))))))
-(defun tab-switcher-mouse-select (event)
-  "Select the window configuration whose line you click on."
-  (interactive "e")
-  (set-buffer (window-buffer (posn-window (event-end event))))
-  (goto-char (posn-point (event-end event)))
-  (tab-switcher-select))
-(defun tab-bar--reusable-frames (all-frames)
-  (cond
-   ((eq all-frames t) (frame-list))
-   ((eq all-frames 'visible) (visible-frame-list))
-   ((framep all-frames) (list all-frames))
-   (t (list (selected-frame)))))
-(defun tab-bar-get-buffer-tab (buffer-or-name &optional all-frames ignore-current-tab)
-  "Return the tab that owns the window whose buffer is BUFFER-OR-NAME.
-BUFFER-OR-NAME may be a buffer or a buffer name, and defaults to
-the current buffer.
-The optional argument ALL-FRAMES specifies the frames to consider:
- t means consider all tabs on all existing frames.
- `visible' means consider all tabs on all visible frames.
- A frame means consider all tabs on that frame only.
- Any other value of ALL-FRAMES means consider all tabs on the
-selected frame and no others.
-When the optional argument IGNORE-CURRENT-TAB is non-nil,
-don't take into account the buffers in the currently selected tab.
-Otherwise, prefer buffers of the current tab."
-  (let ((buffer (if buffer-or-name
-                    (get-buffer buffer-or-name)
-                  (current-buffer))))
-    (when (bufferp buffer)
-      (seq-some
-       (lambda (frame)
-         (seq-some
-          (lambda (tab)
-            (when (if (eq (car tab) 'current-tab)
-                      (get-buffer-window buffer frame)
-                    (let* ((state (alist-get 'ws tab))
-                           (buffers (when state
-                                      (window-state-buffers state))))
-                      (or
-                       ;; non-writable window-state
-                       (memq buffer buffers)
-                       ;; writable window-state
-                       (member (buffer-name buffer) buffers))))
-              (append tab `((index . ,(tab-bar--tab-index tab nil frame))
-                            (frame . ,frame)))))
-          (let* ((tabs (funcall tab-bar-tabs-function frame))
-                 (current-tab (tab-bar--current-tab-find tabs)))
-            (setq tabs (remq current-tab tabs))
-            (if ignore-current-tab
-                ;; Use tabs without current-tab.
-                tabs
-              ;; Make sure current-tab is at the beginning of tabs.
-              (cons current-tab tabs)))))
-       (tab-bar--reusable-frames all-frames)))))
-(defun display-buffer-in-tab (buffer alist)
-  "Display BUFFER in a tab using display actions in ALIST.
-ALIST is an association list of action symbols and values.  See
-Info node `(elisp) Buffer Display Action Alists' for details of
-such alists.
-If ALIST contains a `tab-name' entry, it creates a new tab with that name and
-displays BUFFER in a new tab.  If a tab with this name already exists, it
-switches to that tab before displaying BUFFER.  The `tab-name' entry can be
-a function, in which case it is called with two arguments: BUFFER and ALIST,
-and should return the tab name.  When a `tab-name' entry is omitted, create
-a new tab without an explicit name.
-The ALIST entry `tab-group' (string or function) defines the tab group.
-If ALIST contains a `reusable-frames' entry, its value determines
-which frames to search for a reusable tab:
-  nil -- do not reuse any frames;
-  a frame  -- just that frame;
-  `visible' -- all visible frames;
-  0 -- all frames on the current terminal;
-  t -- all frames;
-  other non-nil values -- use the selected frame.
-If ALIST contains a non-nil `ignore-current-tab' entry, then the buffers
-of the current tab are skipped when searching for a reusable tab.
-Otherwise, prefer buffers of the current tab.
-This is an action function for buffer display, see Info
-node `(elisp) Buffer Display Action Functions'.  It should be
-called only by `display-buffer' or a function directly or
-indirectly called by the latter."
-  (let* ((reusable-frames (alist-get 'reusable-frames alist))
-         (ignore-current-tab (alist-get 'ignore-current-tab alist))
-         (reusable-tab (when reusable-frames
-                         (tab-bar-get-buffer-tab buffer reusable-frames
-                                                 ignore-current-tab))))
-    (if reusable-tab
-        (let* ((frame (alist-get 'frame reusable-tab))
-               (index (alist-get 'index reusable-tab)))
-          (when frame
-            (select-frame-set-input-focus frame))
-          (when index
-            (tab-bar-select-tab (1+ index)))
-          (when (get-buffer-window buffer frame)
-            (select-window (get-buffer-window buffer frame))))
-      (let ((tab-name (alist-get 'tab-name alist)))
-        (when (functionp tab-name)
-          (setq tab-name (funcall tab-name buffer alist)))
-        (if tab-name
-            (let ((tab-index (tab-bar--tab-index-by-name tab-name)))
-              (if tab-index
-                  (progn
-                    (tab-bar-select-tab (1+ tab-index))
-                    (when (get-buffer-window buffer)
-                      (select-window (get-buffer-window buffer))))
-                (display-buffer-in-new-tab buffer alist)))
-          (display-buffer-in-new-tab buffer alist))))))
-(defun display-buffer-in-new-tab (buffer alist)
-  "Display BUFFER in a new tab using display actions in ALIST.
-ALIST is an association list of action symbols and values.  See
-Info node `(elisp) Buffer Display Action Alists' for details of
-such alists.
-Like `display-buffer-in-tab', but always creates a new tab unconditionally,
-without checking if a suitable tab already exists.
-If ALIST contains a `tab-name' entry, it creates a new tab with that name
-and displays BUFFER in a new tab.  The `tab-name' entry can be a function,
-in which case it is called with two arguments: BUFFER and ALIST, and should
-return the tab name.  When a `tab-name' entry is omitted, create a new tab
-without an explicit name.
-The ALIST entry `tab-group' (string or function) defines the tab group.
-This is an action function for buffer display, see Info
-node `(elisp) Buffer Display Action Functions'.  It should be
-called only by `display-buffer' or a function directly or
-indirectly called by the latter."
-  (let ((tab-bar-new-tab-choice t))
-    (tab-bar-new-tab)
-    (let ((tab-name (alist-get 'tab-name alist)))
-      (when (functionp tab-name)
-        (setq tab-name (funcall tab-name buffer alist)))
-      (when tab-name
-        (tab-bar-rename-tab tab-name)))
-    (let ((tab-group (alist-get 'tab-group alist)))
-      (when (functionp tab-group)
-        (setq tab-group (funcall tab-group buffer alist)))
-      (when tab-group
-        (tab-bar-change-tab-group tab-group)))
-    (window--display-buffer buffer (selected-window) 'tab alist)))
-(defun switch-to-buffer-other-tab (buffer-or-name &optional _norecord)
-  "Switch to buffer BUFFER-OR-NAME in another tab.
-Like \\[switch-to-buffer-other-frame] (which see), but creates a new tab.
-Interactively, prompt for the buffer to switch to."
-  (declare (advertised-calling-convention (buffer-or-name) "28.1"))
-  (interactive
-   (list (read-buffer-to-switch "Switch to buffer in other tab: ")))
-  (display-buffer (window-normalize-buffer-to-switch-to buffer-or-name)
-                  '((display-buffer-in-tab)
-                    (inhibit-same-window . nil))))
-(defun find-file-other-tab (filename &optional wildcards)
-  "Edit file FILENAME, in another tab.
-Like \\[find-file-other-frame] (which see), but creates a new tab.
-Interactively, prompt for FILENAME.
-If WILDCARDS is non-nil, FILENAME can include widcards, and all matching
-files will be visited."
-  (interactive
-   (find-file-read-args "Find file in other tab: "
-                        (confirm-nonexistent-file-or-buffer)))
-  (let ((value (find-file-noselect filename nil nil wildcards)))
-    (if (listp value)
-        (progn
-          (setq value (nreverse value))
-          (switch-to-buffer-other-tab (car value))
-          (mapc 'switch-to-buffer (cdr value))
-          value)
-      (switch-to-buffer-other-tab value))))
-(defun find-file-read-only-other-tab (filename &optional wildcards)
-  "Edit file FILENAME, in another tab, but don't allow changes.
-Like \\[find-file-other-frame] (which see), but creates a new tab.
-Like \\[find-file-other-tab], but marks buffer as read-only.
-Use \\[read-only-mode] to permit editing.
-Interactively, prompt for FILENAME.
-If WILDCARDS is non-nil, FILENAME can include widcards, and all matching
-files will be visited."
-  (interactive
-   (find-file-read-args "Find file read-only in other tab: "
-                        (confirm-nonexistent-file-or-buffer)))
-  (find-file--read-only (lambda (filename wildcards)
-                          (window-buffer
-                           (find-file-other-tab filename wildcards)))
-                        filename wildcards))
-(defun other-tab-prefix ()
-  "Display the buffer of the next command in a new tab.
-The next buffer is the buffer displayed by the next command invoked
-immediately after this command (ignoring reading from the minibuffer).
-Creates a new tab before displaying the buffer, or switches to the tab
-that already contains that buffer.
-When `switch-to-buffer-obey-display-actions' is non-nil,
-`switch-to-buffer' commands are also supported."
-  (interactive)
-  (display-buffer-override-next-command
-   (lambda (buffer alist)
-     (cons (progn
-             (display-buffer-in-tab
-              buffer (append alist '((inhibit-same-window . nil))))
-             (selected-window))
-           'tab))
-   nil "[other-tab]")
-  (message "Display next command buffer in a new tab..."))
-;;; Short aliases and keybindings
-(defalias 'tab-new             'tab-bar-new-tab)
-(defalias 'tab-new-to          'tab-bar-new-tab-to)
-(defalias 'tab-duplicate       'tab-bar-duplicate-tab)
-(defalias 'tab-detach          'tab-bar-detach-tab)
-(defalias 'tab-window-detach   'tab-bar-move-window-to-tab)
-(defalias 'tab-close           'tab-bar-close-tab)
-(defalias 'tab-close-other     'tab-bar-close-other-tabs)
-(defalias 'tab-close-group     'tab-bar-close-group-tabs)
-(defalias 'tab-undo            'tab-bar-undo-close-tab)
-(defalias 'tab-select          'tab-bar-select-tab)
-(defalias 'tab-switch          'tab-bar-switch-to-tab)
-(defalias 'tab-next            'tab-bar-switch-to-next-tab)
-(defalias 'tab-previous        'tab-bar-switch-to-prev-tab)
-(defalias 'tab-last            'tab-bar-switch-to-last-tab)
-(defalias 'tab-recent          'tab-bar-switch-to-recent-tab)
-(defalias 'tab-move            'tab-bar-move-tab)
-(defalias 'tab-move-to         'tab-bar-move-tab-to)
-(defalias 'tab-rename          'tab-bar-rename-tab)
-(defalias 'tab-group           'tab-bar-change-tab-group)
-(defalias 'tab-list            'tab-switcher)
-(define-key tab-prefix-map "n" 'tab-duplicate)
-(define-key tab-prefix-map "N" 'tab-new-to)
-(define-key tab-prefix-map "2" 'tab-new)
-(define-key tab-prefix-map "1" 'tab-close-other)
-(define-key tab-prefix-map "0" 'tab-close)
-(define-key tab-prefix-map "u" 'tab-undo)
-(define-key tab-prefix-map "o" 'tab-next)
-(define-key tab-prefix-map "O" 'tab-previous)
-(define-key tab-prefix-map "m" 'tab-move)
-(define-key tab-prefix-map "M" 'tab-move-to)
-(define-key tab-prefix-map "G" 'tab-group)
-(define-key tab-prefix-map "r" 'tab-rename)
-(define-key tab-prefix-map "\r" 'tab-switch)
-(define-key tab-prefix-map "b" 'switch-to-buffer-other-tab)
-(define-key tab-prefix-map "f" 'find-file-other-tab)
-(define-key tab-prefix-map "\C-f" 'find-file-other-tab)
-(define-key tab-prefix-map "\C-r" 'find-file-read-only-other-tab)
-(define-key tab-prefix-map "t" 'other-tab-prefix)
-(defvar tab-bar-switch-repeat-map
-  (let ((map (make-sparse-keymap)))
-    (define-key map "o" 'tab-next)
-    (define-key map "O" 'tab-previous)
-    map)
-  "Keymap to repeat tab switch key sequences `C-x t o o O'.
-Used in `repeat-mode'.")
-(put 'tab-next 'repeat-map 'tab-bar-switch-repeat-map)
-(put 'tab-previous 'repeat-map 'tab-bar-switch-repeat-map)
-(defvar tab-bar-move-repeat-map
-  (let ((map (make-sparse-keymap)))
-    (define-key map "m" 'tab-move)
-    (define-key map "M" 'tab-bar-move-tab-backward)
-    map)
-  "Keymap to repeat tab move key sequences `C-x t m m M'.
-Used in `repeat-mode'.")
-(put 'tab-move 'repeat-map 'tab-bar-move-repeat-map)
-(put 'tab-bar-move-tab-backward 'repeat-map 'tab-bar-move-repeat-map)
-(provide 'tab-bar)
-;;; tab-bar.el ends here