about summary refs log tree commit diff
path: root/configs/shared/emacs/.emacs.d/elpa/ivy-20180911.1701/ivy.el
diff options
context:
space:
mode:
Diffstat (limited to 'configs/shared/emacs/.emacs.d/elpa/ivy-20180911.1701/ivy.el')
-rw-r--r--configs/shared/emacs/.emacs.d/elpa/ivy-20180911.1701/ivy.el4298
1 files changed, 0 insertions, 4298 deletions
diff --git a/configs/shared/emacs/.emacs.d/elpa/ivy-20180911.1701/ivy.el b/configs/shared/emacs/.emacs.d/elpa/ivy-20180911.1701/ivy.el
deleted file mode 100644
index 5eb3b4fbf26f..000000000000
--- a/configs/shared/emacs/.emacs.d/elpa/ivy-20180911.1701/ivy.el
+++ /dev/null
@@ -1,4298 +0,0 @@
-;;; ivy.el --- Incremental Vertical completYon -*- lexical-binding: t -*-
-
-;; Copyright (C) 2015-2018  Free Software Foundation, Inc.
-
-;; Author: Oleh Krehel <ohwoeowho@gmail.com>
-;; URL: https://github.com/abo-abo/swiper
-;; Version: 0.10.0
-;; Package-Requires: ((emacs "24.1"))
-;; Keywords: matching
-
-;; This file is part of GNU Emacs.
-
-;; This file 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, or (at your option)
-;; any later version.
-
-;; This program is distributed in the hope that it will be useful,
-;; but WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-;; GNU General Public License for more details.
-
-;; For a full copy of the GNU General Public License
-;; see <http://www.gnu.org/licenses/>.
-
-;;; Commentary:
-
-;; This package provides `ivy-read' as an alternative to
-;; `completing-read' and similar functions.
-;;
-;; There's no intricate code to determine the best candidate.
-;; Instead, the user can navigate to it with `ivy-next-line' and
-;; `ivy-previous-line'.
-;;
-;; The matching is done by splitting the input text by spaces and
-;; re-building it into a regex.
-;; So "for example" is transformed into "\\(for\\).*\\(example\\)".
-
-;;; Code:
-
-(require 'cl-lib)
-(require 'ffap)
-(require 'ivy-overlay)
-(require 'colir)
-
-;;* Customization
-(defgroup ivy nil
-  "Incremental vertical completion."
-  :group 'convenience)
-
-(defgroup ivy-faces nil
-  "Font-lock faces for `ivy'."
-  :group 'ivy
-  :group 'faces)
-
-(defface ivy-current-match
-  '((((class color) (background light))
-     :background "#1a4b77" :foreground "white")
-    (((class color) (background dark))
-     :background "#65a7e2" :foreground "black"))
-  "Face used by Ivy for highlighting the current match.")
-
-(defface ivy-minibuffer-match-highlight
-  '((t :inherit highlight))
-  "Face used by Ivy for highlighting the match under the cursor.")
-
-(defface ivy-minibuffer-match-face-1
-  '((((class color) (background light))
-     :background "#d3d3d3")
-    (((class color) (background dark))
-     :background "#555555"))
-  "The background face for `ivy' minibuffer matches.")
-
-(defface ivy-minibuffer-match-face-2
-  '((((class color) (background light))
-     :background "#e99ce8" :weight bold)
-    (((class color) (background dark))
-     :background "#777777" :weight bold))
-  "Face for `ivy' minibuffer matches numbered 1 modulo 3.")
-
-(defface ivy-minibuffer-match-face-3
-  '((((class color) (background light))
-     :background "#bbbbff" :weight bold)
-    (((class color) (background dark))
-     :background "#7777ff" :weight bold))
-  "Face for `ivy' minibuffer matches numbered 2 modulo 3.")
-
-(defface ivy-minibuffer-match-face-4
-  '((((class color) (background light))
-     :background "#ffbbff" :weight bold)
-    (((class color) (background dark))
-     :background "#8a498a" :weight bold))
-  "Face for `ivy' minibuffer matches numbered 3 modulo 3.")
-
-(defface ivy-confirm-face
-  '((t :foreground "ForestGreen" :inherit minibuffer-prompt))
-  "Face used by Ivy for a confirmation prompt.")
-
-(defface ivy-match-required-face
-  '((t :foreground "red" :inherit minibuffer-prompt))
-  "Face used by Ivy for a match required prompt.")
-
-(defface ivy-subdir
-  '((t :inherit dired-directory))
-  "Face used by Ivy for highlighting subdirs in the alternatives.")
-
-(defface ivy-modified-buffer
-  '((t :inherit default))
-  "Face used by Ivy for highlighting modified file visiting buffers.")
-
-(defface ivy-modified-outside-buffer
-  '((t :inherit default))
-  "Face used by Ivy for highlighting file visiting buffers modified outside Emacs.")
-
-(defface ivy-remote
-  '((((class color) (background light))
-     :foreground "#110099")
-    (((class color) (background dark))
-     :foreground "#7B6BFF"))
-  "Face used by Ivy for highlighting remotes in the alternatives.")
-
-(defface ivy-virtual
-  '((t :inherit font-lock-builtin-face))
-  "Face used by Ivy for matching virtual buffer names.")
-
-(defface ivy-action
-  '((t :inherit font-lock-builtin-face))
-  "Face used by Ivy for displaying keys in `ivy-read-action'.")
-
-(defface ivy-highlight-face
-  '((t :inherit highlight))
-  "Face used by Ivy to highlight certain candidates.")
-
-(defface ivy-prompt-match
-  '((t :inherit ivy-current-match))
-  "Face used by Ivy for highlighting the selected prompt line.")
-
-(setcdr (assoc load-file-name custom-current-group-alist) 'ivy)
-
-(defcustom ivy-height 10
-  "Number of lines for the minibuffer window.
-
-See also `ivy-height-alist'."
-  :type 'integer)
-
-(defcustom ivy-count-format "%-4d "
-  "The style to use for displaying the current candidate count for `ivy-read'.
-Set this to \"\" to suppress the count visibility.
-Set this to \"(%d/%d) \" to display both the index and the count."
-  :type '(choice
-          (const :tag "Count disabled" "")
-          (const :tag "Count matches" "%-4d ")
-          (const :tag "Count matches and show current match" "(%d/%d) ")
-          string))
-
-(defcustom ivy-add-newline-after-prompt nil
-  "When non-nil, add a newline after the `ivy-read' prompt."
-  :type 'boolean)
-
-(defcustom ivy-wrap nil
-  "When non-nil, wrap around after the first and the last candidate."
-  :type 'boolean)
-
-(defcustom ivy-display-style (and (fboundp 'add-face-text-property) 'fancy)
-  "The style for formatting the minibuffer.
-
-By default, the matched strings are copied as is.
-
-The fancy display style highlights matching parts of the regexp,
-a behavior similar to `swiper'.
-
-This setting depends on `add-face-text-property' - a C function
-available since Emacs 24.4.  Fancy style will render poorly in
-earlier versions of Emacs."
-  :type '(choice
-          (const :tag "Plain" nil)
-          (const :tag "Fancy" fancy)))
-
-(defcustom ivy-on-del-error-function #'abort-recursive-edit
-  "Function to call when deletion fails during completion.
-The usual reason for `ivy-backward-delete-char' to fail is when
-there is no text left to delete, i.e., when it is called at the
-beginning of the minibuffer.
-The default setting provides a quick exit from completion."
-  :type '(choice
-          (const :tag "Exit completion" abort-recursive-edit)
-          (const :tag "Do nothing" ignore)
-          (function :tag "Custom function")))
-
-(defcustom ivy-extra-directories '("../" "./")
-  "Add this to the front of the list when completing file names.
-Only \"./\" and \"../\" apply here.  They appear in reverse order."
-  :type '(repeat :tag "Dirs"
-          (choice
-           (const :tag "Parent Directory" "../")
-           (const :tag "Current Directory" "./"))))
-
-(defcustom ivy-use-virtual-buffers nil
-  "When non-nil, add recent files and bookmarks to `ivy-switch-buffer'."
-  :type 'boolean)
-
-(defcustom ivy-display-function nil
-  "Determine where to display candidates.
-When nil (the default), candidates are shown in the minibuffer.
-Otherwise, this can be set to a function which takes a string
-argument comprising the current matching candidates and displays
-it somewhere.
-
-This user option acts as a global default for Ivy-based
-completion commands.  You can customize the display function on a
-per-command basis via `ivy-display-functions-alist', which see.
-See also URL
-`https://github.com/abo-abo/swiper/wiki/ivy-display-function'."
-  :type '(choice
-          (const :tag "Minibuffer" nil)
-          (const :tag "LV" ivy-display-function-lv)
-          (const :tag "Popup" ivy-display-function-popup)
-          (const :tag "Overlay" ivy-display-function-overlay)))
-
-(defvar ivy-display-functions-props
-  '((ivy-display-function-overlay :cleanup ivy-overlay-cleanup))
-  "Map Ivy display functions to their property lists.
-Examples of properties include associated `:cleanup' functions.")
-
-(defvar ivy-display-functions-alist
-  '((ivy-completion-in-region . ivy-display-function-overlay))
-  "An alist for customizing `ivy-display-function'.")
-
-(defvar ivy-completing-read-dynamic-collection nil
-  "Run `ivy-completing-read' with `:dynamic-collection t`.")
-
-(defcustom ivy-completing-read-handlers-alist
-  '((tmm-menubar . completing-read-default)
-    (tmm-shortcut . completing-read-default)
-    (bbdb-create . ivy-completing-read-with-empty-string-def)
-    (auto-insert . ivy-completing-read-with-empty-string-def)
-    (Info-on-current-buffer . ivy-completing-read-with-empty-string-def)
-    (Info-follow-reference . ivy-completing-read-with-empty-string-def)
-    (Info-menu . ivy-completing-read-with-empty-string-def)
-    (Info-index . ivy-completing-read-with-empty-string-def)
-    (Info-virtual-index . ivy-completing-read-with-empty-string-def)
-    (info-display-manual . ivy-completing-read-with-empty-string-def)
-    (webjump . ivy-completing-read-with-empty-string-def))
-  "An alist of handlers to replace `completing-read' in `ivy-mode'."
-  :type '(alist :key-type function :value-type function))
-
-(defcustom ivy-height-alist nil
-  "An alist to customize `ivy-height'.
-
-It is a list of (CALLER . HEIGHT).  CALLER is a caller of
-`ivy-read' and HEIGHT is the number of lines displayed.
-HEIGHT can also be a function that returns the number of lines."
-  :type '(alist
-          :key-type function
-          :value-type (choice integer function)))
-
-(defvar ivy-completing-read-ignore-handlers-depth -1
-  "Used to avoid infinite recursion.
-
-If `(minibuffer-depth)' equals this, `ivy-completing-read' will
-act as if `ivy-completing-read-handlers-alist' is empty.")
-
-(defvar ivy-highlight-grep-commands nil
-  "List of counsel grep-like commands.")
-
-(defvar ivy--actions-list nil
-  "A list of extra actions per command.")
-
-(defun ivy-set-actions (cmd actions)
-  "Set CMD extra exit points to ACTIONS."
-  (setq ivy--actions-list
-        (plist-put ivy--actions-list cmd actions)))
-
-(defun ivy-add-actions (cmd actions)
-  "Add extra exit points ACTIONS to CMD.
-Existing exit points of CMD are overwritten by those in
-ACTIONS that have the same key."
-  (setq ivy--actions-list
-        (plist-put ivy--actions-list cmd
-                   (cl-delete-duplicates
-                    (append (plist-get ivy--actions-list cmd) actions)
-                    :key #'car :test #'equal))))
-
-(defvar ivy--prompts-list nil)
-
-(defun ivy-set-prompt (caller prompt-fn)
-  "Associate CALLER with PROMPT-FN.
-PROMPT-FN is a function of no arguments that returns a prompt string."
-  (setq ivy--prompts-list
-        (plist-put ivy--prompts-list caller prompt-fn)))
-
-(defvar ivy--display-transformers-list nil
-  "A list of str->str transformers per command.")
-
-(defun ivy-set-display-transformer (cmd transformer)
-  "Set CMD a displayed candidate TRANSFORMER.
-
-It's a lambda that takes a string one of the candidates in the
-collection and returns a string for display, the same candidate
-plus some extra information.
-
-This lambda is called only on the `ivy-height' candidates that
-are about to be displayed, not on the whole collection."
-  (setq ivy--display-transformers-list
-        (plist-put ivy--display-transformers-list cmd transformer)))
-
-(defvar ivy--sources-list nil
-  "A list of extra sources per command.")
-
-(defun ivy-set-sources (cmd sources)
-  "Attach to CMD a list of extra SOURCES.
-
-Each static source is a function that takes no argument and
-returns a list of strings.
-
-The (original-source) determines the position of the original
-dynamic source.
-
-Extra dynamic sources aren't supported yet.
-
-Example:
-
-    (defun small-recentf ()
-      (cl-subseq recentf-list 0 20))
-
-    (ivy-set-sources
-     'counsel-locate
-     '((small-recentf)
-       (original-source)))"
-  (setq ivy--sources-list
-        (plist-put ivy--sources-list cmd sources)))
-
-(defvar ivy-current-prefix-arg nil
-  "Prefix arg to pass to actions.
-This is a global variable that is set by ivy functions for use in
-action functions.")
-
-;;* Keymap
-(require 'delsel)
-(defvar ivy-minibuffer-map
-  (let ((map (make-sparse-keymap)))
-    (define-key map (kbd "C-m") 'ivy-done)
-    (define-key map [down-mouse-1] 'ignore)
-    (define-key map [mouse-1] 'ivy-mouse-done)
-    (define-key map [mouse-3] 'ivy-mouse-dispatching-done)
-    (define-key map (kbd "C-M-m") 'ivy-call)
-    (define-key map (kbd "C-j") 'ivy-alt-done)
-    (define-key map (kbd "C-M-j") 'ivy-immediate-done)
-    (define-key map (kbd "TAB") 'ivy-partial-or-done)
-    (define-key map [remap next-line] 'ivy-next-line)
-    (define-key map [remap previous-line] 'ivy-previous-line)
-    (define-key map (kbd "C-s") 'ivy-next-line-or-history)
-    (define-key map (kbd "C-r") 'ivy-reverse-i-search)
-    (define-key map (kbd "SPC") 'self-insert-command)
-    (define-key map [remap delete-backward-char] 'ivy-backward-delete-char)
-    (define-key map [remap backward-delete-char-untabify] 'ivy-backward-delete-char)
-    (define-key map [remap backward-kill-word] 'ivy-backward-kill-word)
-    (define-key map [remap delete-char] 'ivy-delete-char)
-    (define-key map [remap forward-char] 'ivy-forward-char)
-    (define-key map (kbd "<right>") 'ivy-forward-char)
-    (define-key map [remap kill-word] 'ivy-kill-word)
-    (define-key map [remap beginning-of-buffer] 'ivy-beginning-of-buffer)
-    (define-key map [remap end-of-buffer] 'ivy-end-of-buffer)
-    (define-key map (kbd "M-n") 'ivy-next-history-element)
-    (define-key map (kbd "M-p") 'ivy-previous-history-element)
-    (define-key map (kbd "C-g") 'minibuffer-keyboard-quit)
-    (define-key map [remap scroll-up-command] 'ivy-scroll-up-command)
-    (define-key map [remap scroll-down-command] 'ivy-scroll-down-command)
-    (define-key map (kbd "<next>") 'ivy-scroll-up-command)
-    (define-key map (kbd "<prior>") 'ivy-scroll-down-command)
-    (define-key map (kbd "C-v") 'ivy-scroll-up-command)
-    (define-key map (kbd "M-v") 'ivy-scroll-down-command)
-    (define-key map (kbd "C-M-n") 'ivy-next-line-and-call)
-    (define-key map (kbd "C-M-p") 'ivy-previous-line-and-call)
-    (define-key map (kbd "M-r") 'ivy-toggle-regexp-quote)
-    (define-key map (kbd "M-j") 'ivy-yank-word)
-    (define-key map (kbd "M-i") 'ivy-insert-current)
-    (define-key map (kbd "C-o") 'hydra-ivy/body)
-    (define-key map (kbd "M-o") 'ivy-dispatching-done)
-    (define-key map (kbd "C-M-o") 'ivy-dispatching-call)
-    (define-key map [remap kill-line] 'ivy-kill-line)
-    (define-key map [remap kill-whole-line] 'ivy-kill-whole-line)
-    (define-key map (kbd "S-SPC") 'ivy-restrict-to-matches)
-    (define-key map [remap kill-ring-save] 'ivy-kill-ring-save)
-    (define-key map (kbd "C-'") 'ivy-avy)
-    (define-key map (kbd "C-M-a") 'ivy-read-action)
-    (define-key map (kbd "C-c C-o") 'ivy-occur)
-    (define-key map (kbd "C-c C-a") 'ivy-toggle-ignore)
-    (define-key map (kbd "C-c C-s") 'ivy-rotate-sort)
-    (define-key map [remap describe-mode] 'ivy-help)
-    map)
-  "Keymap used in the minibuffer.")
-(autoload 'hydra-ivy/body "ivy-hydra" "" t)
-
-(defvar ivy-mode-map
-  (let ((map (make-sparse-keymap)))
-    (define-key map [remap switch-to-buffer]
-      'ivy-switch-buffer)
-    (define-key map [remap switch-to-buffer-other-window]
-      'ivy-switch-buffer-other-window)
-    map)
-  "Keymap for `ivy-mode'.")
-
-;;* Globals
-(cl-defstruct ivy-state
-  prompt collection
-  predicate require-match initial-input
-  history preselect keymap update-fn sort
-  ;; The frame in which `ivy-read' was called
-  frame
-  ;; The window in which `ivy-read' was called
-  window
-  ;; The buffer in which `ivy-read' was called
-  buffer
-  ;; The value of `ivy-text' to be used by `ivy-occur'
-  text
-  action
-  unwind
-  re-builder
-  matcher
-  ;; When this is non-nil, call it for each input change to get new candidates
-  dynamic-collection
-  ;; A lambda that transforms candidates only for display
-  display-transformer-fn
-  directory
-  caller
-  current
-  def)
-
-(defvar ivy-last (make-ivy-state)
-  "The last parameters passed to `ivy-read'.
-
-This should eventually become a stack so that you could use
-`ivy-read' recursively.")
-
-(defvar ivy-recursive-last nil)
-
-(defvar ivy-recursive-restore t
-  "When non-nil, restore the above state when exiting the minibuffer.
-This variable is let-bound to nil by functions that take care of
-the restoring themselves.")
-
-(defsubst ivy-set-action (action)
-  "Set the current `ivy-last' field to ACTION."
-  (setf (ivy-state-action ivy-last) action))
-
-(defvar inhibit-message)
-
-(defun ivy-thing-at-point ()
-  "Return a string that corresponds to the current thing at point."
-  (substring-no-properties
-   (cond
-    ((thing-at-point 'url))
-    ((and (eq (ivy-state-collection ivy-last) #'read-file-name-internal)
-          (let ((inhibit-message t))
-            (ignore-errors
-              (ffap-file-at-point)))))
-    ((let ((s (thing-at-point 'symbol)))
-       (and (stringp s)
-            (if (string-match "\\`[`']?\\(.*?\\)'?\\'" s)
-                (match-string 1 s)
-              s))))
-    ((looking-at "(+\\(\\(?:\\sw\\|\\s_\\)+\\)\\_>")
-     (match-string-no-properties 1))
-    (t
-     ""))))
-
-(defvar ivy-history nil
-  "History list of candidates entered in the minibuffer.
-
-Maximum length of the history list is determined by the value
-of `history-length'.")
-
-(defvar ivy--directory nil
-  "Current directory when completing file names.")
-
-(defvar ivy--length 0
-  "Store the amount of viable candidates.")
-
-(defvar ivy-text ""
-  "Store the user's string as it is typed in.")
-
-(defvar ivy--index 0
-  "Store the index of the current candidate.")
-
-(defvar ivy--window-index 0
-  "Store the index of the current candidate in the minibuffer window.
-
-This means it's between 0 and `ivy-height'.")
-
-(defvar ivy-exit nil
-  "Store `done' if the completion was successfully selected.
-Otherwise, store nil.")
-
-(defvar ivy--all-candidates nil
-  "Store the candidates passed to `ivy-read'.")
-
-(defvar ivy--extra-candidates '((original-source))
-  "Store candidates added by the extra sources.
-
-This is an internal-use alist.  Each key is a function name, or
-original-source (which represents where the current dynamic
-candidates should go).
-
-Each value is an evaluation of the function, in case of static
-sources.  These values will subsequently be filtered on `ivy-text'.
-
-This variable is set by `ivy-read' and used by `ivy--set-candidates'.")
-
-(defcustom ivy-use-ignore-default t
-  "The default policy for user-configured candidate filtering."
-  :type '(choice
-          (const :tag "Ignore ignored always" always)
-          (const :tag "Ignore ignored when others exist" t)
-          (const :tag "Don't ignore" nil)))
-
-(defvar ivy-use-ignore t
-  "Store policy for user-configured candidate filtering.
-This may be changed dynamically by `ivy-toggle-ignore'.
-Use `ivy-use-ignore-default' for a permanent configuration.")
-
-(defvar ivy--default nil
-  "Default initial input.")
-
-(defvar ivy--prompt nil
-  "Store the format-style prompt.
-When non-nil, it should contain at least one %d.")
-
-(defvar ivy--prompt-extra ""
-  "Temporary modifications to the prompt.")
-
-(defvar ivy--old-re nil
-  "Store the old regexp.
-Either a string or a list for `ivy-re-match'.")
-
-(defvar ivy--old-cands nil
-  "Store the candidates matched by `ivy--old-re'.")
-
-(defvar ivy--regex-function 'ivy--regex
-  "Current function for building a regex.")
-
-(defvar ivy--highlight-function 'ivy--highlight-default
-  "Current function for formatting the candidates.")
-
-(defvar ivy--subexps 0
-  "Number of groups in the current `ivy--regex'.")
-
-(defvar ivy--full-length nil
-  "The total amount of candidates when :dynamic-collection is non-nil.")
-
-(defvar ivy--old-text ""
-  "Store old `ivy-text' for dynamic completion.")
-
-(defcustom ivy-case-fold-search-default
-  (if search-upper-case
-      'auto
-    case-fold-search)
-  "The default value for `case-fold-search' in Ivy operations.
-The special value `auto' means case folding is performed so long
-as the entire input string comprises lower-case characters.  This
-corresponds to the default behaviour of most Emacs search
-functionality, e.g. as seen in `isearch'."
-  :link '(info-link "(emacs)Lax Search")
-  :type '(choice
-          (const :tag "Auto" auto)
-          (const :tag "Always" t)
-          (const :tag "Never" nil)))
-
-(defvar ivy-case-fold-search ivy-case-fold-search-default
-  "Store the current overriding `case-fold-search'.")
-
-(defun ivy--case-fold-p (string)
-  "Return nil if STRING should be matched case-sensitively."
-  (if (eq ivy-case-fold-search 'auto)
-      (string= string (downcase string))
-    ivy-case-fold-search))
-
-(defun ivy--case-fold-string= (s1 s2)
-  "Like `string=', but obeys `case-fold-search'."
-  (eq t (compare-strings s1 nil nil s2 nil nil case-fold-search)))
-
-(defun ivy-re-to-str (re)
-  (if (stringp re)
-      re
-    (caar re)))
-
-(eval-and-compile
-  (unless (fboundp 'defvar-local)
-    (defmacro defvar-local (var val &optional docstring)
-      "Define VAR as a buffer-local variable with default value VAL."
-      (declare (debug defvar) (doc-string 3))
-      (list 'progn (list 'defvar var val docstring)
-            (list 'make-variable-buffer-local (list 'quote var)))))
-  (unless (fboundp 'setq-local)
-    (defmacro setq-local (var val)
-      "Set variable VAR to value VAL in current buffer."
-      (list 'set (list 'make-local-variable (list 'quote var)) val))))
-
-(defmacro ivy-quit-and-run (&rest body)
-  "Quit the minibuffer and run BODY afterwards."
-  (declare (indent 0))
-  `(progn
-     (put 'quit 'error-message "")
-     (run-at-time nil nil
-                  (lambda ()
-                    (put 'quit 'error-message "Quit")
-                    (with-demoted-errors "Error: %S"
-                      ,@body)))
-     (abort-recursive-edit)))
-
-(defun ivy-exit-with-action (action)
-  "Quit the minibuffer and call ACTION afterwards."
-  (ivy-set-action
-   `(lambda (x)
-      (funcall ',action x)
-      (ivy-set-action ',(ivy-state-action ivy-last))))
-  (setq ivy-exit 'done)
-  (exit-minibuffer))
-
-(defmacro with-ivy-window (&rest body)
-  "Execute BODY in the window from which `ivy-read' was called."
-  (declare (indent 0)
-           (debug t))
-  `(with-selected-window (ivy--get-window ivy-last)
-     ,@body))
-
-(defun ivy--done (text)
-  "Insert TEXT and exit minibuffer."
-  (insert
-   (setf (ivy-state-current ivy-last)
-         (if (and ivy--directory
-                  (not (eq (ivy-state-history ivy-last) 'grep-files-history)))
-             (expand-file-name text ivy--directory)
-           text)))
-  (setq ivy-exit 'done)
-  (exit-minibuffer))
-
-(defcustom ivy-use-selectable-prompt nil
-  "When non-nil, make the prompt line selectable like a candidate.
-
-The prompt line can be selected by calling `ivy-previous-line' when the first
-regular candidate is selected.  Both actions `ivy-done' and `ivy-alt-done',
-when called on a selected prompt, are forwarded to `ivy-immediate-done', which
-results to the same as calling `ivy-immediate-done' explicitly when a regular
-candidate is selected.
-
-Note that if `ivy-wrap' is set to t, calling `ivy-previous-line' when the
-prompt is selected wraps around to the last candidate, while calling
-`ivy-next-line' on the last candidate wraps around to the first
-candidate, not the prompt."
-  :type 'boolean)
-
-(defun ivy--prompt-selectable-p ()
-  "Return t if the prompt line is selectable."
-  (and ivy-use-selectable-prompt
-       (memq (ivy-state-require-match ivy-last)
-             '(nil confirm confirm-after-completion))))
-
-(defun ivy--prompt-selected-p ()
-  "Return t if the prompt line is selected."
-  (and (ivy--prompt-selectable-p)
-       (= ivy--index -1)))
-
-;;* Commands
-(defun ivy-done ()
-  "Exit the minibuffer with the selected candidate."
-  (interactive)
-  (if (ivy--prompt-selected-p)
-      (ivy-immediate-done)
-    (setq ivy-current-prefix-arg current-prefix-arg)
-    (delete-minibuffer-contents)
-    (cond ((or (> ivy--length 0)
-               ;; the action from `ivy-dispatching-done' may not need a
-               ;; candidate at all
-               (eq this-command 'ivy-dispatching-done))
-           (ivy--done (ivy-state-current ivy-last)))
-          ((memq (ivy-state-collection ivy-last)
-                 '(read-file-name-internal internal-complete-buffer))
-           (if (or (not (eq confirm-nonexistent-file-or-buffer t))
-                   (equal " (confirm)" ivy--prompt-extra))
-               (ivy--done ivy-text)
-             (setq ivy--prompt-extra " (confirm)")
-             (insert ivy-text)
-             (ivy--exhibit)))
-          ((memq (ivy-state-require-match ivy-last)
-                 '(nil confirm confirm-after-completion))
-           (ivy--done ivy-text))
-          (t
-           (setq ivy--prompt-extra " (match required)")
-           (insert ivy-text)
-           (ivy--exhibit)))))
-
-(defvar ivy-mouse-1-tooltip
-  "Exit the minibuffer with the selected candidate."
-  "The doc visible in the tooltip for mouse-1 binding in the minibuffer")
-(defvar ivy-mouse-3-tooltip
-  "Display alternative actions."
-  "The doc visible in the tooltip for mouse-3 binding in the minibuffer")
-
-(defun ivy-mouse-offset (event)
-  "Compute the offset between the candidate at point and the selected one."
-  (if event
-      (let* ((line-number-at-point
-              (max 2
-                   (line-number-at-pos (posn-point (event-start event)))))
-
-             (line-number-candidate ;; convert to 0 based index
-              (- line-number-at-point 2))
-             (offset
-              (- line-number-candidate
-                 ivy--window-index)))
-        offset)
-    nil))
-
-(defun ivy-mouse-done (event)
-  (interactive "@e")
-  (let ((offset (ivy-mouse-offset event)))
-    (when offset
-      (ivy-next-line offset)
-      (ivy--exhibit)
-      (ivy-alt-done))))
-
-(defun ivy-mouse-dispatching-done (event)
-  (interactive "@e")
-  (let ((offset (ivy-mouse-offset event)))
-    (when offset
-      (ivy-next-line offset)
-      (ivy--exhibit)
-      (ivy-dispatching-done))))
-
-(defvar ivy-read-action-format-function 'ivy-read-action-format-default
-  "Function used to transform the actions list into a docstring.")
-
-(defun ivy-read-action-format-default (actions)
-  "Create a docstring from ACTIONS.
-
-ACTIONS is a list.  Each list item is a list of 3 items:
-key (a string), cmd and doc (a string)."
-  (format "%s\n%s\n"
-          (if (eq this-command 'ivy-read-action)
-              "Select action: "
-            (ivy-state-current ivy-last))
-          (mapconcat
-           (lambda (x)
-             (format "%s: %s"
-                     (propertize
-                      (car x)
-                      'face 'ivy-action)
-                     (nth 2 x)))
-           actions
-           "\n")))
-
-(defun ivy-read-action ()
-  "Change the action to one of the available ones.
-
-Return nil for `minibuffer-keyboard-quit' or wrong key during the
-selection, non-nil otherwise."
-  (interactive)
-  (let ((actions (ivy-state-action ivy-last)))
-    (if (not (ivy--actionp actions))
-        t
-      (let* ((hint (funcall ivy-read-action-format-function (cdr actions)))
-             (resize-mini-windows t)
-             (key "")
-             action-idx)
-        (while (and (setq action-idx (cl-position-if
-                                      (lambda (x)
-                                        (string-prefix-p key (car x)))
-                                      (cdr actions)))
-                    (not (string= key (car (nth action-idx (cdr actions))))))
-          (setq key (concat key (string (read-key hint)))))
-        (cond ((member key '("" ""))
-               nil)
-              ((null action-idx)
-               (message "%s is not bound" key)
-               nil)
-              (t
-               (message "")
-               (setcar actions (1+ action-idx))
-               (ivy-set-action actions)))))))
-
-(defun ivy-shrink-after-dispatching ()
-  "Shrink the window after dispatching when action list is too large."
-  (let ((window (selected-window)))
-    (window-resize window (- ivy-height (window-height window)))))
-
-(defun ivy-dispatching-done ()
-  "Select one of the available actions and call `ivy-done'."
-  (interactive)
-  (when (ivy-read-action)
-    (ivy-done))
-  (ivy-shrink-after-dispatching))
-
-(defun ivy-dispatching-call ()
-  "Select one of the available actions and call `ivy-call'."
-  (interactive)
-  (setq ivy-current-prefix-arg current-prefix-arg)
-  (let ((actions (copy-sequence (ivy-state-action ivy-last))))
-    (unwind-protect
-         (when (ivy-read-action)
-           (ivy-call))
-      (ivy-set-action actions)))
-  (ivy-shrink-after-dispatching))
-
-(defun ivy-build-tramp-name (x)
-  "Reconstruct X into a path.
-Is is a cons cell, related to `tramp-get-completion-function'."
-  (let ((user (car x))
-        (domain (cadr x)))
-    (if user
-        (concat user "@" domain)
-      domain)))
-
-(declare-function Info-find-node "info")
-(declare-function Info-read-node-name-1 "info")
-(declare-function tramp-get-completion-function "tramp")
-
-(defun ivy-alt-done (&optional arg)
-  "Exit the minibuffer with the selected candidate.
-When ARG is t, exit with current text, ignoring the candidates.
-When the current candidate during file name completion is a
-directory, continue completion from within that directory instead
-of exiting.  This function is otherwise like `ivy-done'."
-  (interactive "P")
-  (setq ivy-current-prefix-arg current-prefix-arg)
-  (cond ((or arg
-             (ivy--prompt-selected-p))
-         (ivy-immediate-done))
-        (ivy--directory
-         (ivy--directory-done))
-        ((eq (ivy-state-collection ivy-last) #'Info-read-node-name-1)
-         (if (member (ivy-state-current ivy-last) '("(./)" "(../)"))
-             (ivy-quit-and-run
-               (ivy-read "Go to file: " #'read-file-name-internal
-                         :action (lambda (x)
-                                   (Info-find-node
-                                    (expand-file-name x ivy--directory)
-                                    "Top"))))
-           (ivy-done)))
-        (t
-         (ivy-done))))
-
-(defvar ivy-auto-select-single-candidate nil
-  "When non-nil, auto-select the candidate if it is the only one.
-When t, it is the same as if the user were prompted and selected the candidate
-by calling the default action.  This variable has no use unless the collection
-contains a single candidate.")
-
-(defun ivy--directory-done ()
-  "Handle exit from the minibuffer when completing file names."
-  (let (dir)
-    (cond
-      ((equal ivy-text "/sudo::")
-       (setq dir (concat ivy-text (expand-file-name ivy--directory)))
-       (ivy--cd dir)
-       (ivy--exhibit))
-      ((and
-        (> ivy--length 0)
-        (not (string= (ivy-state-current ivy-last) "./"))
-        (setq dir (ivy-expand-file-if-directory (ivy-state-current ivy-last))))
-       (ivy--cd dir)
-       (ivy--exhibit))
-      ((unless (string= ivy-text "")
-         (let ((file (expand-file-name
-                      (if (> ivy--length 0) (ivy-state-current ivy-last) ivy-text)
-                      ivy--directory)))
-           (when (ignore-errors (file-exists-p file))
-             (if (file-directory-p file)
-                 (ivy--cd (file-name-as-directory file))
-               (ivy-done))
-             ivy-text))))
-      ((or (and (equal ivy--directory "/")
-                (string-match-p "\\`[^/]+:.*:.*\\'" ivy-text))
-           (string-match-p "\\`/[^/]+:.*:.*\\'" ivy-text))
-       (ivy-done))
-      ((or (and (equal ivy--directory "/")
-                (cond ((string-match
-                        "\\`\\([^/]+?\\):\\(?:\\(.*\\)@\\)?\\(.*\\)\\'"
-                        ivy-text)
-                       (setq ivy-text (ivy-state-current ivy-last)))
-                      ((string-match
-                        "\\`\\([^/]+?\\):\\(?:\\(.*\\)@\\)?\\(.*\\)\\'"
-                        (ivy-state-current ivy-last))
-                       (setq ivy-text (ivy-state-current ivy-last)))))
-           (string-match
-            "\\`/\\([^/]+?\\):\\(?:\\(.*\\)@\\)?\\(.*\\)\\'"
-            ivy-text))
-       (let ((method (match-string 1 ivy-text))
-             (user (match-string 2 ivy-text))
-             (rest (match-string 3 ivy-text))
-             res)
-         (require 'tramp)
-         (dolist (x (tramp-get-completion-function method))
-           (setq res (append res (funcall (car x) (cadr x)))))
-         (setq res (delq nil res))
-         (when user
-           (dolist (x res)
-             (setcar x user)))
-         (setq res (delete-dups res))
-         (let* ((old-ivy-last ivy-last)
-                (enable-recursive-minibuffers t)
-                (host (let ((ivy-auto-select-single-candidate nil))
-                        (ivy-read "user@host: "
-                                  (mapcar #'ivy-build-tramp-name res)
-                                  :initial-input rest))))
-           (setq ivy-last old-ivy-last)
-           (when host
-             (setq ivy--directory "/")
-             (ivy--cd (concat "/" method ":" host ":"))))))
-      (t
-       (ivy-done)))))
-
-(defun ivy-expand-file-if-directory (file-name)
-  "Expand FILE-NAME as directory.
-When this directory doesn't exist, return nil."
-  (when (stringp file-name)
-    (let ((full-name
-           ;; Ignore host name must not match method "ssh"
-           (ignore-errors
-             (file-name-as-directory
-              (expand-file-name file-name ivy--directory)))))
-      (when (and full-name (file-directory-p full-name))
-        full-name))))
-
-(defcustom ivy-tab-space nil
-  "When non-nil, `ivy-partial-or-done' should insert a space."
-  :type 'boolean)
-
-(defun ivy-partial-or-done ()
-  "Complete the minibuffer text as much as possible.
-If the text hasn't changed as a result, forward to `ivy-alt-done'."
-  (interactive)
-  (if (and (eq (ivy-state-collection ivy-last) #'read-file-name-internal)
-           (or (and (equal ivy--directory "/")
-                    (string-match-p "\\`[^/]+:.*\\'" ivy-text))
-               (string-match-p "\\`/" ivy-text)))
-      (let ((default-directory ivy--directory)
-            dir)
-        (minibuffer-complete)
-        (setq ivy-text (ivy--input))
-        (when (setq dir (ivy-expand-file-if-directory ivy-text))
-          (ivy--cd dir)))
-    (or (ivy-partial)
-        (when (or (eq this-command last-command)
-                  (eq ivy--length 1))
-          (ivy-alt-done)))))
-
-(defun ivy-partial ()
-  "Complete the minibuffer text as much as possible."
-  (interactive)
-  (let* ((parts (or (split-string ivy-text " " t) (list "")))
-         (postfix (car (last parts)))
-         (case-fold-search (ivy--case-fold-p ivy-text))
-         (completion-ignore-case case-fold-search)
-         (startp (string-match-p "\\`\\^" postfix))
-         (new (try-completion (if startp
-                                  (substring postfix 1)
-                                postfix)
-                              (if (ivy-state-dynamic-collection ivy-last)
-                                  ivy--all-candidates
-                                (mapcar (lambda (str)
-                                          (let ((i (string-match-p postfix str)))
-                                            (when i
-                                              (substring str i))))
-                                        ivy--old-cands)))))
-    (cond ((eq new t) nil)
-          ((string= new ivy-text) nil)
-          (new
-           (delete-region (minibuffer-prompt-end) (point-max))
-           (setcar (last parts)
-                   (if startp
-                       (concat "^" new)
-                     new))
-           (insert
-            (setq ivy-text
-                  (concat
-                   (mapconcat #'identity parts " ")
-                   (if ivy-tab-space " " ""))))
-           (when (and
-                  (eq (ivy-state-collection ivy-last) #'read-file-name-internal)
-                  (= 1 (length
-                        (all-completions ivy-text ivy--all-candidates)))
-                  (let ((default-directory ivy--directory))
-                    (file-directory-p (ivy-state-current ivy-last))))
-             (ivy--directory-done))
-           t))))
-
-(defvar ivy-completion-beg nil
-  "Completion bounds start.")
-
-(defvar ivy-completion-end nil
-  "Completion bounds end.")
-
-(defun ivy-immediate-done ()
-  "Exit the minibuffer with current input instead of current candidate."
-  (interactive)
-  (delete-minibuffer-contents)
-  (insert (setf (ivy-state-current ivy-last)
-                (if (and ivy--directory
-                         (not (eq (ivy-state-history ivy-last)
-                                  'grep-files-history)))
-                    (expand-file-name ivy-text ivy--directory)
-                  ivy-text)))
-  (setq ivy-completion-beg ivy-completion-end)
-  (setq ivy-exit 'done)
-  (exit-minibuffer))
-
-;;;###autoload
-(defun ivy-resume ()
-  "Resume the last completion session."
-  (interactive)
-  (if (null (ivy-state-action ivy-last))
-      (user-error "The last session isn't compatible with `ivy-resume'")
-    (when (eq (ivy-state-caller ivy-last) 'swiper)
-      (switch-to-buffer (ivy-state-buffer ivy-last)))
-    (with-current-buffer (ivy-state-buffer ivy-last)
-      (let ((default-directory (ivy-state-directory ivy-last)))
-        (ivy-read
-         (ivy-state-prompt ivy-last)
-         (ivy-state-collection ivy-last)
-         :predicate (ivy-state-predicate ivy-last)
-         :require-match (ivy-state-require-match ivy-last)
-         :initial-input ivy-text
-         :history (ivy-state-history ivy-last)
-         :preselect (ivy-state-current ivy-last)
-         :keymap (ivy-state-keymap ivy-last)
-         :update-fn (ivy-state-update-fn ivy-last)
-         :sort (ivy-state-sort ivy-last)
-         :action (ivy-state-action ivy-last)
-         :unwind (ivy-state-unwind ivy-last)
-         :re-builder (ivy-state-re-builder ivy-last)
-         :matcher (ivy-state-matcher ivy-last)
-         :dynamic-collection (ivy-state-dynamic-collection ivy-last)
-         :caller (ivy-state-caller ivy-last))))))
-
-(defvar-local ivy-calling nil
-  "When non-nil, call the current action when `ivy--index' changes.")
-
-(defun ivy-set-index (index)
-  "Set `ivy--index' to INDEX."
-  (setq ivy--index index)
-  (when ivy-calling
-    (ivy--exhibit)
-    (ivy-call)))
-
-(defun ivy-beginning-of-buffer ()
-  "Select the first completion candidate."
-  (interactive)
-  (ivy-set-index 0))
-
-(defun ivy-end-of-buffer ()
-  "Select the last completion candidate."
-  (interactive)
-  (ivy-set-index (1- ivy--length)))
-
-(defun ivy-scroll-up-command ()
-  "Scroll the candidates upward by the minibuffer height."
-  (interactive)
-  (ivy-set-index (min (1- (+ ivy--index ivy-height))
-                      (1- ivy--length))))
-
-(defun ivy-scroll-down-command ()
-  "Scroll the candidates downward by the minibuffer height."
-  (interactive)
-  (ivy-set-index (max (1+ (- ivy--index ivy-height))
-                      0)))
-
-(defun ivy-minibuffer-grow ()
-  "Grow the minibuffer window by 1 line."
-  (interactive)
-  (setq-local max-mini-window-height
-              (cl-incf ivy-height)))
-
-(defun ivy-minibuffer-shrink ()
-  "Shrink the minibuffer window by 1 line."
-  (interactive)
-  (unless (<= ivy-height 2)
-    (setq-local max-mini-window-height
-                (cl-decf ivy-height))
-    (window-resize (selected-window) -1)))
-
-(defun ivy-next-line (&optional arg)
-  "Move cursor vertically down ARG candidates."
-  (interactive "p")
-  (setq arg (or arg 1))
-  (let ((index (+ ivy--index arg)))
-    (if (> index (1- ivy--length))
-        (if ivy-wrap
-            (ivy-beginning-of-buffer)
-          (ivy-set-index (1- ivy--length)))
-      (ivy-set-index index))))
-
-(defun ivy-next-line-or-history (&optional arg)
-  "Move cursor vertically down ARG candidates.
-If the input is empty, select the previous history element instead."
-  (interactive "p")
-  (if (string= ivy-text "")
-      (ivy-previous-history-element 1)
-    (ivy-next-line arg)))
-
-(defun ivy-previous-line (&optional arg)
-  "Move cursor vertically up ARG candidates."
-  (interactive "p")
-  (setq arg (or arg 1))
-  (let ((index (- ivy--index arg))
-        (min-index (or (and (ivy--prompt-selectable-p) -1)
-                       0)))
-    (if (< index min-index)
-        (if ivy-wrap
-            (ivy-end-of-buffer)
-          (ivy-set-index min-index))
-      (ivy-set-index index))))
-
-(defun ivy-previous-line-or-history (arg)
-  "Move cursor vertically up ARG candidates.
-If the input is empty, select the previous history element instead."
-  (interactive "p")
-  (when (and (zerop ivy--index) (string= ivy-text ""))
-    (ivy-previous-history-element 1))
-  (ivy-previous-line arg))
-
-(defun ivy-toggle-calling ()
-  "Flip `ivy-calling'."
-  (interactive)
-  (when (setq ivy-calling (not ivy-calling))
-    (ivy-call)))
-
-(defun ivy-toggle-ignore ()
-  "Toggle user-configured candidate filtering."
-  (interactive)
-  (setq ivy-use-ignore
-        (if ivy-use-ignore
-            nil
-          (or ivy-use-ignore-default t)))
-  ;; invalidate cache
-  (setq ivy--old-cands nil))
-
-(defun ivy--get-action (state)
-  "Get the action function from STATE."
-  (let ((action (ivy-state-action state)))
-    (when action
-      (if (functionp action)
-          action
-        (cadr (nth (car action) action))))))
-
-(defun ivy--get-window (state)
-  "Get the window from STATE."
-  (if (ivy-state-p state)
-      (let ((window (ivy-state-window state)))
-        (if (window-live-p window)
-            window
-          (if (= (length (window-list)) 1)
-              (selected-window)
-            (next-window))))
-    (selected-window)))
-
-(defun ivy--actionp (x)
-  "Return non-nil when X is a list of actions."
-  (and (consp x) (not (memq (car x) '(closure lambda)))))
-
-(defcustom ivy-action-wrap nil
-  "When non-nil, `ivy-next-action' and `ivy-prev-action' wrap."
-  :type 'boolean)
-
-(defun ivy-next-action ()
-  "When the current action is a list, scroll it forwards."
-  (interactive)
-  (let ((action (ivy-state-action ivy-last)))
-    (when (ivy--actionp action)
-      (let ((len (1- (length action)))
-            (idx (car action)))
-        (if (>= idx len)
-            (when ivy-action-wrap
-              (setf (car action) 1))
-          (cl-incf (car action)))))))
-
-(defun ivy-prev-action ()
-  "When the current action is a list, scroll it backwards."
-  (interactive)
-  (let ((action (ivy-state-action ivy-last)))
-    (when (ivy--actionp action)
-      (if (<= (car action) 1)
-          (when ivy-action-wrap
-            (setf (car action) (1- (length action))))
-        (cl-decf (car action))))))
-
-(defun ivy-action-name ()
-  "Return the name associated with the current action."
-  (let ((action (ivy-state-action ivy-last)))
-    (if (ivy--actionp action)
-        (format "[%d/%d] %s"
-                (car action)
-                (1- (length action))
-                (nth 2 (nth (car action) action)))
-      "[1/1] default")))
-
-(defvar ivy-inhibit-action nil
-  "When non-nil, `ivy-call' does nothing.
-
-Example use:
-
-    (let* ((ivy-inhibit-action t)
-          (str (counsel-locate \"lispy.el\")))
-     ;; do whatever with str - the corresponding file will not be opened
-     )")
-
-(defun ivy-recursive-restore ()
-  "Restore the above state when exiting the minibuffer.
-See variable `ivy-recursive-restore' for further information."
-  (when (and ivy-recursive-last
-             ivy-recursive-restore
-             (not (eq ivy-last ivy-recursive-last)))
-    (ivy--reset-state (setq ivy-last ivy-recursive-last))))
-
-(defun ivy-call ()
-  "Call the current action without exiting completion."
-  (interactive)
-  ;; Testing with `ivy-with' seems to call `ivy-call' again,
-  ;; in which case `this-command' is nil; so check for this.
-  (unless (memq this-command '(nil
-                               ivy-done
-                               ivy-alt-done
-                               ivy-dispatching-done))
-    (setq ivy-current-prefix-arg current-prefix-arg))
-  (let ((action (and (not ivy-inhibit-action)
-                     (ivy--get-action ivy-last))))
-    (when action
-      (let* ((collection (ivy-state-collection ivy-last))
-             (current (ivy-state-current ivy-last))
-             (x (cond
-                 ;; Alist type.
-                 ((and (consp (car-safe collection))
-                       ;; Previously, the cdr of the selected
-                       ;; candidate would be returned.  Now, the
-                       ;; whole candidate is returned.
-                       (let ((idx (get-text-property 0 'idx current)))
-                         (if idx
-                             (nth idx collection)
-                           (assoc current collection)))))
-                 (ivy--directory
-                  (expand-file-name current ivy--directory))
-                 ((equal current "")
-                  ivy-text)
-                 (t
-                  current))))
-        (if (eq action #'identity)
-            (funcall action x)
-          (select-window (ivy--get-window ivy-last))
-          (set-buffer (ivy-state-buffer ivy-last))
-          (prog1 (with-current-buffer (ivy-state-buffer ivy-last)
-                   (unwind-protect (funcall action x)
-                     (ivy-recursive-restore)))
-            (unless (or (eq ivy-exit 'done)
-                        (minibuffer-window-active-p (selected-window))
-                        (null (active-minibuffer-window)))
-              (select-window (active-minibuffer-window)))))))))
-
-(defun ivy-call-and-recenter ()
-  "Call action and recenter window according to the selected candidate."
-  (interactive)
-  (ivy-call)
-  (with-ivy-window
-    (recenter-top-bottom)))
-
-(defun ivy-next-line-and-call (&optional arg)
-  "Move cursor vertically down ARG candidates.
-Call the permanent action if possible."
-  (interactive "p")
-  (ivy-next-line arg)
-  (ivy--exhibit)
-  (ivy-call))
-
-(defun ivy-previous-line-and-call (&optional arg)
-  "Move cursor vertically down ARG candidates.
-Call the permanent action if possible."
-  (interactive "p")
-  (ivy-previous-line arg)
-  (ivy--exhibit)
-  (ivy-call))
-
-(defun ivy-previous-history-element (arg)
-  "Forward to `previous-history-element' with ARG."
-  (interactive "p")
-  (previous-history-element arg)
-  (ivy--cd-maybe)
-  (move-end-of-line 1)
-  (ivy--maybe-scroll-history))
-
-(defun ivy-next-history-element (arg)
-  "Forward to `next-history-element' with ARG."
-  (interactive "p")
-  (if (and (= minibuffer-history-position 0)
-           (equal ivy-text ""))
-      (progn
-        (insert ivy--default)
-        (when (and (with-ivy-window (derived-mode-p 'prog-mode))
-                   (eq (ivy-state-caller ivy-last) 'swiper)
-                   (not (file-exists-p ivy--default))
-                   (not (ffap-url-p ivy--default))
-                   (not (ivy-state-dynamic-collection ivy-last))
-                   (> (point) (minibuffer-prompt-end)))
-          (undo-boundary)
-          (insert "\\_>")
-          (goto-char (minibuffer-prompt-end))
-          (insert "\\_<")
-          (forward-char (+ 2 (length ivy--default)))))
-    (next-history-element arg))
-  (ivy--cd-maybe)
-  (move-end-of-line 1)
-  (ivy--maybe-scroll-history))
-
-(defvar ivy-ffap-url-functions nil
-  "List of functions that check if the point is on a URL.")
-
-(defun ivy--cd-maybe ()
-  "Check if the current input points to a different directory.
-If so, move to that directory, while keeping only the file name."
-  (when ivy--directory
-    (let ((input (ivy--input))
-          url)
-      (if (setq url (or (ffap-url-p input)
-                        (with-ivy-window
-                          (cl-reduce
-                           (lambda (a b)
-                             (or a (funcall b)))
-                           ivy-ffap-url-functions
-                           :initial-value nil))))
-          (ivy-exit-with-action
-           (lambda (_)
-             (funcall ffap-url-fetcher url)))
-        (setq input (expand-file-name input))
-        (let ((file (file-name-nondirectory input))
-              (dir (expand-file-name (file-name-directory input))))
-          (if (string= dir ivy--directory)
-              (progn
-                (delete-minibuffer-contents)
-                (insert file))
-            (ivy--cd dir)
-            (insert file)))))))
-
-(defun ivy--maybe-scroll-history ()
-  "If the selected history element has an index, scroll there."
-  (let ((idx (ignore-errors
-               (get-text-property
-                (minibuffer-prompt-end)
-                'ivy-index))))
-    (when idx
-      (ivy--exhibit)
-      (ivy-set-index idx))))
-
-(declare-function tramp-get-completion-methods "tramp")
-
-(defun ivy--cd (dir)
-  "When completing file names, move to directory DIR."
-  (if (null ivy--directory)
-      (error "Unexpected")
-    (setq ivy--old-cands nil)
-    (setq ivy--old-re nil)
-    (ivy-set-index 0)
-    (setq ivy--all-candidates
-          (append
-           (ivy--sorted-files (setq ivy--directory dir))
-           (when (and (string= dir "/") (featurep 'tramp))
-             (sort (mapcar #'file-name-nondirectory (tramp-get-completion-methods "")) #'string<))))
-    (setq ivy-text "")
-    (setf (ivy-state-directory ivy-last) dir)
-    (delete-minibuffer-contents)))
-
-(defun ivy--parent-dir (filename)
-  "Return parent directory of absolute FILENAME."
-  (file-name-directory (directory-file-name filename)))
-
-(defun ivy-backward-delete-char ()
-  "Forward to `delete-backward-char'.
-Call `ivy-on-del-error-function' if an error occurs, usually when
-there is no more text to delete at the beginning of the
-minibuffer."
-  (interactive)
-  (if (and ivy--directory (= (minibuffer-prompt-end) (point)))
-      (progn
-        (ivy--cd (ivy--parent-dir (expand-file-name ivy--directory)))
-        (ivy--exhibit))
-    (setq prefix-arg current-prefix-arg)
-    (condition-case nil
-        (call-interactively #'delete-backward-char)
-      (error
-       (when ivy-on-del-error-function
-         (funcall ivy-on-del-error-function))))))
-
-(defun ivy-delete-char (arg)
-  "Forward to `delete-char' ARG."
-  (interactive "p")
-  (unless (eolp)
-    (delete-char arg)))
-
-(defun ivy-forward-char (arg)
-  "Forward to `forward-char' ARG."
-  (interactive "p")
-  (unless (eolp)
-    (forward-char arg)))
-
-(defun ivy-kill-word (arg)
-  "Forward to `kill-word' ARG."
-  (interactive "p")
-  (unless (eolp)
-    (kill-word arg)))
-
-(defun ivy-kill-line ()
-  "Forward to `kill-line'."
-  (interactive)
-  (if (eolp)
-      (kill-region (minibuffer-prompt-end) (point))
-    (kill-line)))
-
-(defun ivy-kill-whole-line ()
-  "Forward to `kill-whole-line'."
-  (interactive)
-  (kill-region (minibuffer-prompt-end) (line-end-position)))
-
-(defun ivy-backward-kill-word ()
-  "Forward to `backward-kill-word'."
-  (interactive)
-  (if (and ivy--directory (= (minibuffer-prompt-end) (point)))
-      (progn
-        (ivy--cd (ivy--parent-dir (expand-file-name ivy--directory)))
-        (ivy--exhibit))
-    (ignore-errors
-      (let ((pt (point)))
-        (forward-word -1)
-        (delete-region (point) pt)))))
-
-(defvar ivy--regexp-quote #'regexp-quote
-  "Store the regexp quoting state.")
-
-(defun ivy-toggle-regexp-quote ()
-  "Toggle the regexp quoting."
-  (interactive)
-  (setq ivy--old-re nil)
-  (cl-rotatef ivy--regex-function ivy--regexp-quote))
-
-(defvar avy-all-windows)
-(defvar avy-action)
-(defvar avy-keys)
-(defvar avy-keys-alist)
-(defvar avy-style)
-(defvar avy-styles-alist)
-(declare-function avy--process "ext:avy")
-(declare-function avy--style-fn "ext:avy")
-
-(defcustom ivy-format-function #'ivy-format-function-default
-  "Function to transform the list of candidates into a string.
-This string is inserted into the minibuffer."
-  :type '(choice
-          (const :tag "Default" ivy-format-function-default)
-          (const :tag "Arrow prefix" ivy-format-function-arrow)
-          (const :tag "Full line" ivy-format-function-line)))
-
-(eval-after-load 'avy
-  '(add-to-list 'avy-styles-alist '(ivy-avy . pre)))
-
-(defun ivy-avy ()
-  "Jump to one of the current ivy candidates."
-  (interactive)
-  (unless (require 'avy nil 'noerror)
-    (error "Package avy isn't installed"))
-  (let* ((avy-all-windows nil)
-         (avy-keys (or (cdr (assq 'ivy-avy avy-keys-alist))
-                       avy-keys))
-         (avy-style (or (cdr (assq 'ivy-avy
-                                   avy-styles-alist))
-                        avy-style))
-         (candidate
-          (let ((candidates))
-            (save-excursion
-              (save-restriction
-                (narrow-to-region
-                 (window-start)
-                 (window-end))
-                (goto-char (point-min))
-                (forward-line)
-                (while (< (point) (point-max))
-                  (push
-                   (cons (point)
-                         (selected-window))
-                   candidates)
-                  (forward-line))))
-            (setq avy-action #'identity)
-            (avy--process
-             (nreverse candidates)
-             (avy--style-fn avy-style)))))
-    (when (number-or-marker-p candidate)
-      (ivy--done
-       (substring-no-properties
-        (nth (- (line-number-at-pos candidate) 2) ivy--old-cands))))))
-
-(defun ivy-sort-file-function-default (x y)
-  "Compare two files X and Y.
-Prioritize directories."
-  (if (get-text-property 0 'dirp x)
-      (if (get-text-property 0 'dirp y)
-          (string< (directory-file-name x) (directory-file-name y))
-        t)
-    (if (get-text-property 0 'dirp y)
-        nil
-      (string< x y))))
-
-(declare-function ido-file-extension-lessp "ido")
-
-(defun ivy-sort-file-function-using-ido (x y)
-  "Compare two files X and Y using `ido-file-extensions-order'.
-
-This function is suitable as a replacement for
-`ivy-sort-file-function-default' in `ivy-sort-functions-alist'."
-  (if (and (bound-and-true-p ido-file-extensions-order))
-      (ido-file-extension-lessp x y)
-    (ivy-sort-file-function-default x y)))
-
-(defun ivy-string< (x y)
-  "Like `string<', but operate on CARs when given cons cells."
-  (string< (if (consp x) (car x) x)
-           (if (consp y) (car y) y)))
-
-(defcustom ivy-sort-functions-alist
-  '((read-file-name-internal . ivy-sort-file-function-default)
-    (internal-complete-buffer . nil)
-    (ivy-completion-in-region . nil)
-    (counsel-git-grep-function . nil)
-    (Man-goto-section . nil)
-    (org-refile . nil)
-    (t . ivy-string<))
-  "An alist of sorting functions for each collection function.
-Interactive functions that call completion fit in here as well.
-
-Nil means no sorting, which is useful to turn off the sorting for
-functions that have candidates in the natural buffer order, like
-`org-refile' or `Man-goto-section'.
-
-A list can be used to associate multiple sorting functions with a
-collection.  The car of the list is the current sort
-function.  This list can be rotated with `ivy-rotate-sort'.
-
-The entry associated with t is used for all fall-through cases.
-
-See also `ivy-sort-max-size'."
-  :type
-  '(alist
-    :key-type (choice
-               (const :tag "Fall-through" t)
-               (symbol :tag "Collection"))
-    :value-type (choice
-                 (const :tag "Plain sort" string-lessp)
-                 (const :tag "File sort" ivy-sort-file-function-default)
-                 (const :tag "No sort" nil)
-                 (function :tag "Custom function")
-                 (repeat (function :tag "Custom function"))))
-  :group 'ivy)
-
-(defun ivy--sort-function (collection)
-  "Retrieve sort function for COLLECTION from `ivy-sort-functions-alist'."
-  (let ((entry (cdr (or (assq collection ivy-sort-functions-alist)
-                        (assq (ivy-state-caller ivy-last) ivy-sort-functions-alist)
-                        (assq t ivy-sort-functions-alist)))))
-    (and (or (functionp entry)
-             (functionp (setq entry (car-safe entry))))
-         entry)))
-
-(defun ivy-rotate-sort ()
-  "Rotate through sorting functions available for current collection.
-This only has an effect if multiple sorting functions are
-specified for the current collection in
-`ivy-sort-functions-alist'."
-  (interactive)
-  (let ((cell (or (assq (ivy-state-collection ivy-last) ivy-sort-functions-alist)
-                  (assq (ivy-state-caller ivy-last) ivy-sort-functions-alist))))
-    (when (consp (cdr cell))
-      (setcdr cell (nconc (cddr cell) (list (cadr cell))))
-      (ivy--reset-state ivy-last))))
-
-(defvar ivy-index-functions-alist
-  '((swiper . ivy-recompute-index-swiper)
-    (swiper-multi . ivy-recompute-index-swiper)
-    (counsel-git-grep . ivy-recompute-index-swiper)
-    (counsel-grep . ivy-recompute-index-swiper-async)
-    (t . ivy-recompute-index-zero))
-  "An alist of index recomputing functions for each collection function.
-When the input changes, the appropriate function returns an
-integer - the index of the matched candidate that should be
-selected.")
-
-(defvar ivy-re-builders-alist
-  '((t . ivy--regex-plus))
-  "An alist of regex building functions for each collection function.
-
-Each key is (in order of priority):
-1. The actual collection function, e.g. `read-file-name-internal'.
-2. The symbol passed by :caller into `ivy-read'.
-3. `this-command'.
-4. t.
-
-Each value is a function that should take a string and return a
-valid regex or a regex sequence (see below).
-
-Possible choices: `ivy--regex', `regexp-quote',
-`ivy--regex-plus', `ivy--regex-fuzzy', `ivy--regex-ignore-order'.
-
-If a function returns a list, it should format like this:
-'((\"matching-regexp\" . t) (\"non-matching-regexp\") ...).
-
-The matches will be filtered in a sequence, you can mix the
-regexps that should match and that should not match as you
-like.")
-
-(defvar ivy-highlight-functions-alist
-  '((ivy--regex-ignore-order . ivy--highlight-ignore-order)
-    (ivy--regex-fuzzy . ivy--highlight-fuzzy)
-    (ivy--regex-plus . ivy--highlight-default))
-  "An alist of highlighting functions for each regex buidler function.")
-
-(defvar ivy-initial-inputs-alist
-  '((org-refile . "^")
-    (org-agenda-refile . "^")
-    (org-capture-refile . "^")
-    (counsel-M-x . "^")
-    (counsel-describe-function . "^")
-    (counsel-describe-variable . "^")
-    (counsel-org-capture . "^")
-    (Man-completion-table . "^")
-    (woman . "^"))
-  "Command to initial input table.")
-
-(defcustom ivy-sort-max-size 30000
-  "Sorting won't be done for collections larger than this."
-  :type 'integer)
-
-(defalias 'ivy--dirname-p
-  (if (fboundp 'directory-name-p)
-      #'directory-name-p
-    (lambda (name)
-      "Return non-nil if NAME ends with a directory separator."
-      (string-match-p "/\\'" name))))
-
-(defun ivy--sorted-files (dir)
-  "Return the list of files in DIR.
-Directories come first."
-  (let* ((default-directory dir)
-         (predicate (ivy-state-predicate ivy-last))
-         (seq (condition-case nil
-                  (all-completions "" #'read-file-name-internal)
-                (error
-                 (directory-files dir))))
-         (seq (if predicate
-                  (cl-remove-if-not predicate seq)
-                seq))
-         sort-fn)
-    (setq seq (delete "./" (delete "../" seq)))
-    (when (eq (setq sort-fn (ivy--sort-function #'read-file-name-internal))
-              #'ivy-sort-file-function-default)
-      (setq seq (mapcar (lambda (x)
-                          (propertize x 'dirp (ivy--dirname-p x)))
-                        seq)))
-    (when sort-fn
-      (setq seq (sort seq sort-fn)))
-    (dolist (dir ivy-extra-directories)
-      (push dir seq))
-    (if (string= dir "/")
-        (cl-remove-if (lambda (s) (string-match ":$" s)) (delete "../" seq))
-      seq)))
-
-(defun ivy-alist-setting (alist &optional key)
-  "Return the value associated with KEY in ALIST, using `assq'.
-KEY defaults to the last caller of `ivy-read'; if no entry is
-found, it falls back to the key t."
-  (cdr (or (let ((caller (or key (ivy-state-caller ivy-last))))
-             (and caller (assq caller alist)))
-           (assq t alist))))
-
-(defun ivy--height (caller)
-  (let ((v (or (ivy-alist-setting ivy-height-alist caller)
-               ivy-height)))
-    (if (integerp v)
-        v
-      (if (functionp v)
-          (funcall v caller)
-        (error "Unexpected value: %S" v)))))
-
-;;** Entry Point
-;;;###autoload
-(cl-defun ivy-read (prompt collection
-                    &key
-                      predicate require-match initial-input
-                      history preselect def keymap update-fn sort
-                      action unwind re-builder matcher
-                      dynamic-collection caller)
-  "Read a string in the minibuffer, with completion.
-
-PROMPT is a format string, normally ending in a colon and a
-space; %d anywhere in the string is replaced by the current
-number of matching candidates.  For the literal % character,
-escape it with %%. See also `ivy-count-format'.
-
-COLLECTION is either a list of strings, a function, an alist, or
-a hash table.
-
-PREDICATE is applied to filter out the COLLECTION immediately.
-This argument is for `completing-read' compat.
-
-When REQUIRE-MATCH is non-nil, only members of COLLECTION can be
-selected, i.e. custom text.
-
-If INITIAL-INPUT is not nil, then insert that input in the
-minibuffer initially.
-
-HISTORY is a name of a variable to hold the completion session
-history.
-
-KEYMAP is composed with `ivy-minibuffer-map'.
-
-If PRESELECT is not nil, then select the corresponding candidate
-out of the ones that match the INITIAL-INPUT.
-
-DEF is for compatibility with `completing-read'.
-
-UPDATE-FN is called each time the current candidate(s) is changed.
-
-When SORT is t, use `ivy-sort-functions-alist' for sorting.
-
-ACTION is a lambda function to call after selecting a result.  It
-takes a single string argument.
-
-UNWIND is a lambda function to call before exiting.
-
-RE-BUILDER is a lambda function to call to transform text into a
-regex pattern.
-
-MATCHER is to override matching.
-
-DYNAMIC-COLLECTION is a boolean to specify if the list of
-candidates is updated after each input by calling COLLECTION.
-
-CALLER is a symbol to uniquely identify the caller to `ivy-read'.
-It is used, along with COLLECTION, to determine which
-customizations apply to the current completion session."
-  (let ((extra-actions (delete-dups
-                        (append (plist-get ivy--actions-list t)
-                                (plist-get ivy--actions-list this-command)
-                                (plist-get ivy--actions-list caller)))))
-    (when extra-actions
-      (setq action
-            (cond ((functionp action)
-                   `(1
-                     ("o" ,action "default")
-                     ,@extra-actions))
-                  ((null action)
-                   `(1
-                     ("o" identity "default")
-                     ,@extra-actions))
-                  (t
-                   (delete-dups (append action extra-actions)))))))
-  (unless caller
-    (setq caller this-command))
-  (let ((extra-sources (plist-get ivy--sources-list caller)))
-    (if extra-sources
-        (progn
-          (setq ivy--extra-candidates nil)
-          (dolist (source extra-sources)
-            (cond ((equal source '(original-source))
-                   (setq ivy--extra-candidates
-                         (cons source ivy--extra-candidates)))
-                  ((null (cdr source))
-                   (setq ivy--extra-candidates
-                         (cons
-                          (list (car source) (funcall (car source)))
-                          ivy--extra-candidates))))))
-      (setq ivy--extra-candidates '((original-source)))))
-  (let ((ivy-recursive-last (and (active-minibuffer-window) ivy-last))
-        (transformer-fn
-         (plist-get ivy--display-transformers-list
-                    (cond (caller)
-                          ((functionp collection)
-                           collection))))
-        (ivy-display-function
-         (unless (window-minibuffer-p)
-           (or ivy-display-function
-               (ivy-alist-setting ivy-display-functions-alist caller))))
-        (height (ivy--height caller)))
-    (setq ivy-last
-          (make-ivy-state
-           :prompt prompt
-           :collection collection
-           :predicate predicate
-           :require-match require-match
-           :initial-input initial-input
-           :history history
-           :preselect preselect
-           :keymap keymap
-           :update-fn update-fn
-           :sort sort
-           :action action
-           :frame (selected-frame)
-           :window (selected-window)
-           :buffer (current-buffer)
-           :unwind unwind
-           :re-builder re-builder
-           :matcher matcher
-           :dynamic-collection dynamic-collection
-           :display-transformer-fn transformer-fn
-           :directory default-directory
-           :caller caller
-           :def def))
-    (ivy--reset-state ivy-last)
-    (prog1
-        (unwind-protect
-             (minibuffer-with-setup-hook
-                 #'ivy--minibuffer-setup
-               (let* ((hist (or history 'ivy-history))
-                      (minibuffer-completion-table collection)
-                      (minibuffer-completion-predicate predicate)
-                      (ivy-height height)
-                      (resize-mini-windows
-                       (cond
-                         ((display-graphic-p) nil)
-                         ((null resize-mini-windows) 'grow-only)
-                         (t resize-mini-windows))))
-                 (if (and ivy-auto-select-single-candidate
-                          (= (length ivy--all-candidates) 1))
-                     (progn
-                       (setf (ivy-state-current ivy-last)
-                             (car ivy--all-candidates))
-                       (setq ivy-exit 'done))
-                   (read-from-minibuffer
-                    prompt
-                    (ivy-state-initial-input ivy-last)
-                    (make-composed-keymap keymap ivy-minibuffer-map)
-                    nil
-                    hist))
-                 (when (eq ivy-exit 'done)
-                   (let ((item (if ivy--directory
-                                   (ivy-state-current ivy-last)
-                                 ivy-text)))
-                     (unless (equal item "")
-                       (set hist (cons (propertize item 'ivy-index ivy--index)
-                                       (delete item
-                                               (cdr (symbol-value hist))))))))
-                 (ivy-state-current ivy-last)))
-          ;; Fixes a bug in ESS, #1660
-          (put 'post-command-hook 'permanent-local nil)
-          (remove-hook 'post-command-hook #'ivy--queue-exhibit)
-          (let ((cleanup (ivy--display-function-prop :cleanup)))
-            (when (functionp cleanup)
-              (funcall cleanup)))
-          (when (setq unwind (ivy-state-unwind ivy-last))
-            (funcall unwind))
-          (unless (eq ivy-exit 'done)
-            (ivy-recursive-restore)))
-      (ivy-call)
-      (let ((cur (ivy-state-current ivy-last)))
-        (remove-list-of-text-properties 0 (length cur) '(idx) cur)))))
-
-(defun ivy--display-function-prop (prop)
-  "Return PROP associated with current `ivy-display-function'."
-  (plist-get (cdr (assq ivy-display-function
-                        ivy-display-functions-props))
-             prop))
-
-(defun ivy--reset-state (state)
-  "Reset the ivy to STATE.
-This is useful for recursive `ivy-read'."
-  (unless (equal (selected-frame) (ivy-state-frame state))
-    (select-window (active-minibuffer-window)))
-  (let* ((prompt (or (ivy-state-prompt state) ""))
-         (collection (ivy-state-collection state))
-         (predicate (ivy-state-predicate state))
-         (history (ivy-state-history state))
-         (preselect (ivy-state-preselect state))
-         (sort (ivy-state-sort state))
-         (re-builder (ivy-state-re-builder state))
-         (dynamic-collection (ivy-state-dynamic-collection state))
-         (require-match (ivy-state-require-match state))
-         (caller (or (ivy-state-caller state) this-command))
-         (initial-input (or (ivy-state-initial-input state)
-                            (cdr (assq caller ivy-initial-inputs-alist))))
-         (def (ivy-state-def state)))
-    (setq ivy--directory nil)
-    (setq ivy-case-fold-search ivy-case-fold-search-default)
-    (setq ivy--regex-function
-          (or re-builder
-              (and (functionp collection)
-                   (cdr (assq collection ivy-re-builders-alist)))
-              (ivy-alist-setting ivy-re-builders-alist)
-              #'ivy--regex))
-    (setq ivy--subexps 0)
-    (setq ivy--regexp-quote #'regexp-quote)
-    (setq ivy--old-text "")
-    (setq ivy--full-length nil)
-    (setq ivy-text "")
-    (setq ivy--index 0)
-    (setq ivy-calling nil)
-    (setq ivy-use-ignore ivy-use-ignore-default)
-    (setq ivy--highlight-function
-          (or (cdr (assq ivy--regex-function ivy-highlight-functions-alist))
-              #'ivy--highlight-default))
-    (let (coll sort-fn)
-      (cond ((eq collection #'Info-read-node-name-1)
-             (setq coll
-                   (if (equal (bound-and-true-p Info-current-file) "dir")
-                       (mapcar (lambda (x) (format "(%s)" x))
-                               (delete-dups
-                                (all-completions "(" collection predicate)))
-                     (all-completions "" collection predicate))))
-            ((eq collection #'read-file-name-internal)
-             (when (and (equal def initial-input)
-                        (member "./" ivy-extra-directories))
-               (setf (ivy-state-def state) (setq def nil)))
-             (setq ivy--directory default-directory)
-             (when (and initial-input
-                        (not (equal initial-input "")))
-               (cond ((file-directory-p initial-input)
-                      (when (equal (file-name-nondirectory initial-input) "")
-                        (setf (ivy-state-preselect state) (setq preselect nil))
-                        (setf (ivy-state-def state) (setq def nil)))
-                      (setq ivy--directory (file-name-as-directory initial-input))
-                      (setq initial-input nil)
-                      (when preselect
-                        (let ((preselect-directory
-                               (file-name-directory preselect)))
-                          (when (and preselect-directory
-                                     (not (equal
-                                           (expand-file-name
-                                            preselect-directory)
-                                           (expand-file-name ivy--directory))))
-                            (setf (ivy-state-preselect state)
-                                  (setq preselect nil))))))
-                     ((ignore-errors
-                        (file-exists-p (file-name-directory initial-input)))
-                      (setq ivy--directory (file-name-directory initial-input))
-                      (setf (ivy-state-preselect state)
-                            (file-name-nondirectory initial-input)))))
-             (require 'dired)
-             (when preselect
-               (let ((preselect-directory (ivy--parent-dir preselect)))
-                 (when (and preselect-directory
-                            (not (string= preselect-directory
-                                          default-directory)))
-                   (setq ivy--directory preselect-directory))
-                 (setq preselect (file-relative-name preselect
-                                                     preselect-directory))
-                 (setf (ivy-state-preselect state) preselect)))
-             (setq sort nil)
-             (setq coll (ivy--sorted-files ivy--directory))
-             (when initial-input
-               (unless (or require-match
-                           (equal initial-input default-directory)
-                           (equal initial-input ""))
-                 (setq coll (cons initial-input coll)))
-               (when (or (not (ivy-state-action ivy-last))
-                         (equal (ivy--get-action ivy-last) 'identity))
-                 (setq initial-input nil))))
-            ((eq collection #'internal-complete-buffer)
-             (setq coll (ivy--buffer-list "" ivy-use-virtual-buffers predicate)))
-            (dynamic-collection
-             (setq coll (funcall collection ivy-text)))
-            ((consp (car-safe collection))
-             (setq collection (cl-remove-if-not predicate collection))
-             (when (and sort (setq sort-fn (ivy--sort-function caller)))
-               (setq collection (sort (copy-sequence collection) sort-fn))
-               (setq sort nil))
-             (setf (ivy-state-collection ivy-last) collection)
-             (setq coll (let ((i -1))
-                          (mapcar (lambda (x)
-                                    (propertize x 'idx (cl-incf i)))
-                                  (all-completions "" collection)))))
-            ((or (functionp collection)
-                 (byte-code-function-p collection)
-                 (vectorp collection)
-                 (hash-table-p collection)
-                 (and (listp collection) (symbolp (car collection))))
-             (setq coll (all-completions "" collection predicate)))
-            (t
-             (setq coll
-                   (if predicate
-                       (cl-remove-if-not predicate collection)
-                     collection))))
-      (unless (ivy-state-dynamic-collection ivy-last)
-        (setq coll (delete "" coll)))
-      (when def
-        (cond ((listp def)
-               (setq coll (cl-union def coll :test #'equal)))
-              ((not (member def coll))
-               (push def coll))))
-      (when (and sort
-                 (or (functionp collection)
-                     (not (eq history 'org-refile-history)))
-                 (setq sort-fn (ivy--sort-function
-                                (if (functionp collection) collection caller)))
-                 (null (nthcdr ivy-sort-max-size coll)))
-        (setq coll (sort (copy-sequence coll) sort-fn)))
-      (setq coll (ivy--set-candidates coll))
-      (setq ivy--old-re nil)
-      (setq ivy--old-cands nil)
-      (when (integerp preselect)
-        (setq ivy--old-re "")
-        (ivy-set-index preselect))
-      (when initial-input
-        ;; Needed for anchor to work
-        (setq ivy--old-cands coll)
-        (setq ivy--old-cands (ivy--filter initial-input coll)))
-      (setq ivy--all-candidates coll)
-      (unless (integerp preselect)
-        (ivy-set-index (or
-                        (and dynamic-collection
-                             ivy--index)
-                        (and preselect
-                             (ivy--preselect-index
-                              preselect
-                              (if initial-input
-                                  ivy--old-cands
-                                coll)))
-                        0))))
-    (setq ivy-exit nil)
-    (setq ivy--default
-          (if (region-active-p)
-              (buffer-substring (region-beginning) (region-end))
-            (ivy-thing-at-point)))
-    (setq ivy--prompt (ivy-add-prompt-count prompt))
-    (setf (ivy-state-initial-input ivy-last) initial-input)))
-
-(defun ivy-add-prompt-count (prompt)
-  "Add count information to PROMPT."
-  (cond ((string-match-p "%.*d" prompt)
-         prompt)
-        ((null ivy-count-format)
-         (error
-          "`ivy-count-format' can't be nil.  Set it to \"\" instead"))
-        ((string-match "%d.*\\(%d\\)" ivy-count-format)
-         (let* ((w (1+ (floor (log (max 1 (length ivy--all-candidates)) 10))))
-                (s (replace-match (format "%%-%dd" w) t t ivy-count-format 1)))
-           (string-match "%d" s)
-           (concat (replace-match (format "%%%dd" w) t t s)
-                   prompt)))
-        ((string-match-p "%.*d" ivy-count-format)
-         (concat ivy-count-format prompt))
-        (ivy--directory
-         prompt)
-        (t
-         prompt)))
-
-;;;###autoload
-(defun ivy-completing-read (prompt collection
-                            &optional predicate require-match initial-input
-                              history def inherit-input-method)
-  "Read a string in the minibuffer, with completion.
-
-This interface conforms to `completing-read' and can be used for
-`completing-read-function'.
-
-PROMPT is a string that normally ends in a colon and a space.
-COLLECTION is either a list of strings, an alist, an obarray, or a hash table.
-PREDICATE limits completion to a subset of COLLECTION.
-REQUIRE-MATCH is a boolean value.  See `completing-read'.
-INITIAL-INPUT is a string inserted into the minibuffer initially.
-HISTORY is a list of previously selected inputs.
-DEF is the default value.
-INHERIT-INPUT-METHOD is currently ignored."
-  (let ((handler
-         (when (< ivy-completing-read-ignore-handlers-depth (minibuffer-depth))
-           (assq this-command ivy-completing-read-handlers-alist))))
-    (if handler
-        (let ((completion-in-region-function #'completion--in-region)
-              (ivy-completing-read-ignore-handlers-depth (1+ (minibuffer-depth))))
-          (funcall (cdr handler)
-                   prompt collection
-                   predicate require-match
-                   initial-input history
-                   def inherit-input-method))
-      ;; See the doc of `completing-read'.
-      (when (consp history)
-        (when (numberp (cdr history))
-          (setq initial-input (nth (1- (cdr history))
-                                   (symbol-value (car history)))))
-        (setq history (car history)))
-      (ivy-read (replace-regexp-in-string "%" "%%" prompt)
-                collection
-                :predicate predicate
-                :require-match (and collection require-match)
-                :initial-input (cond ((consp initial-input)
-                                      (car initial-input))
-                                     ((and (stringp initial-input)
-                                           (not (eq collection #'read-file-name-internal))
-                                           (string-match-p "\\+" initial-input))
-                                      (replace-regexp-in-string
-                                       "\\+" "\\\\+" initial-input))
-                                     (t
-                                      initial-input))
-                :preselect (if (listp def) (car def) def)
-                :def (if (listp def) (car def) def)
-                :history history
-                :keymap nil
-                :sort t
-                :dynamic-collection ivy-completing-read-dynamic-collection
-                :caller (cond ((called-interactively-p 'any)
-                               this-command)
-                              ((and collection (symbolp collection))
-                               collection))))))
-
-(defun ivy-completing-read-with-empty-string-def
-    (prompt collection
-     &optional predicate require-match initial-input
-       history def inherit-input-method)
-  "Same as `ivy-completing-read' but with different handling of DEF.
-
-Specifically, if DEF is nil, it is treated the same as if DEF was
-the empty string. This mimics the behavior of
-`completing-read-default'. This function can therefore be used in
-place of `ivy-completing-read' for commands that rely on this
-behavior."
-  (ivy-completing-read
-   prompt collection predicate require-match initial-input
-   history (or def "") inherit-input-method))
-
-(defun ivy-completion-in-region-action (str)
-  "Insert STR, erasing the previous one.
-The previous string is between `ivy-completion-beg' and `ivy-completion-end'."
-  (when (consp str)
-    (setq str (cdr str)))
-  (when (stringp str)
-    (let ((fake-cursors (and (fboundp 'mc/all-fake-cursors)
-                             (mc/all-fake-cursors)))
-          (pt (point))
-          (beg ivy-completion-beg)
-          (end ivy-completion-end))
-      (when beg
-        (delete-region beg end))
-      (setq ivy-completion-beg (point))
-      (insert (substring-no-properties str))
-      (setq ivy-completion-end (point))
-      (save-excursion
-        (dolist (cursor fake-cursors)
-          (goto-char (overlay-start cursor))
-          (delete-region (+ (point) (- beg pt))
-                         (+ (point) (- end pt)))
-          (insert (substring-no-properties str))
-          ;; manually move the fake cursor
-          (move-overlay cursor (point) (1+ (point)))
-          (set-marker (overlay-get cursor 'point) (point))
-          (set-marker (overlay-get cursor 'mark) (point)))))))
-
-(defun ivy-completion-common-length (str)
-  "Return the amount of characters that match in  STR.
-
-`completion-all-completions' computes this and returns the result
-via text properties.
-
-The first non-matching part is propertized:
-- either with: (face (completions-first-difference))
-- or: (font-lock-face completions-first-difference)."
-  (let ((char-property-alias-alist '((face font-lock-face)))
-        (i (1- (length str))))
-    (catch 'done
-      (while (>= i 0)
-        (when (equal (get-text-property i 'face str)
-                     '(completions-first-difference))
-          (throw 'done i))
-        (cl-decf i))
-      (throw 'done (length str)))))
-
-(defun ivy-completion-in-region (start end collection &optional predicate)
-  "An Ivy function suitable for `completion-in-region-function'.
-The function completes the text between START and END using COLLECTION.
-PREDICATE (a function called with no arguments) says when to exit.
-See `completion-in-region' for further information."
-  (let* ((enable-recursive-minibuffers t)
-         (str (buffer-substring-no-properties start end))
-         (completion-ignore-case (ivy--case-fold-p str))
-         (comps
-          (completion-all-completions str collection predicate (- end start)))
-         (ivy--prompts-list (if (window-minibuffer-p)
-                                ivy--prompts-list
-                              (list #'ivy-completion-in-region (lambda ())))))
-    (cond ((null comps)
-           (message "No matches"))
-          ((progn
-             (nconc comps nil)
-             (and (null (cdr comps))
-                  (string= str (car comps))))
-           (message "Sole match"))
-          (t
-           (let* ((len (ivy-completion-common-length (car comps)))
-                  (str-len (length str))
-                  (initial (cond ((= len 0)
-                                  "")
-                                 ((> len str-len)
-                                  (setq len str-len)
-                                  str)
-                                 (t
-                                  (substring str (- len))))))
-             (setq ivy--old-re nil)
-             (unless (ivy--filter initial comps)
-               (setq initial nil))
-             (delete-region (- end len) end)
-             (setq ivy-completion-beg (- end len))
-             (setq ivy-completion-end ivy-completion-beg)
-             (if (null (cdr comps))
-                 (progn
-                   (unless (minibuffer-window-active-p (selected-window))
-                     (setf (ivy-state-window ivy-last) (selected-window)))
-                   (ivy-completion-in-region-action
-                    (substring-no-properties
-                     (car comps))))
-               (let* ((w (1+ (floor (log (length comps) 10))))
-                      (ivy-count-format (if (string= ivy-count-format "")
-                                            ivy-count-format
-                                          (format "%%-%dd " w)))
-                      (prompt (format "(%s): " str)))
-                 (and
-                  (ivy-read (if (string= ivy-count-format "")
-                                prompt
-                              (replace-regexp-in-string "%" "%%" prompt))
-                            ;; remove 'completions-first-difference face
-                            (mapcar
-                             (lambda (s) (remove-text-properties 0 (length s) '(face) s) s)
-                             comps)
-                            ;; predicate was already applied by `completion-all-completions'
-                            :predicate nil
-                            :initial-input initial
-                            :sort t
-                            :action #'ivy-completion-in-region-action
-                            :unwind (lambda ()
-                                      (unless (eq ivy-exit 'done)
-                                        (goto-char ivy-completion-beg)
-                                        (insert initial)))
-                            :caller 'ivy-completion-in-region)
-                  t))))))))
-
-(defcustom ivy-do-completion-in-region t
-  "When non-nil `ivy-mode' will set `completion-in-region-function'."
-  :type 'boolean)
-
-;;;###autoload
-(define-minor-mode ivy-mode
-  "Toggle Ivy mode on or off.
-Turn Ivy mode on if ARG is positive, off otherwise.
-Turning on Ivy mode sets `completing-read-function' to
-`ivy-completing-read'.
-
-Global bindings:
-\\{ivy-mode-map}
-
-Minibuffer bindings:
-\\{ivy-minibuffer-map}"
-  :group 'ivy
-  :global t
-  :keymap ivy-mode-map
-  :lighter " ivy"
-  (if ivy-mode
-      (progn
-        (setq completing-read-function 'ivy-completing-read)
-        (when ivy-do-completion-in-region
-          (setq completion-in-region-function 'ivy-completion-in-region)))
-    (setq completing-read-function 'completing-read-default)
-    (setq completion-in-region-function 'completion--in-region)))
-
-(defun ivy--preselect-index (preselect candidates)
-  "Return the index of PRESELECT in CANDIDATES."
-  (cond ((integerp preselect)
-         preselect)
-        ((cl-position preselect candidates :test #'equal))
-        ((stringp preselect)
-         (let ((re preselect))
-           (cl-position-if
-            (lambda (x)
-              (string-match-p re x))
-            candidates)))))
-
-;;* Implementation
-;;** Regex
-(defun ivy-re-match (re-seq str)
-  "Return non-nil if RE-SEQ is matched by STR.
-
-RE-SEQ is a list of (RE . MATCH-P).
-
-RE is a regular expression.
-
-MATCH-P is t when RE should match STR and nil when RE should not
-match STR.
-
-Each element of RE-SEQ must match for the function to return true.
-
-This concept is used to generalize regular expressions for
-`ivy--regex-plus' and `ivy--regex-ignore-order'."
-  (let ((res t)
-        re)
-    (while (and res (setq re (pop re-seq)))
-      (setq res
-            (if (cdr re)
-                (string-match-p (car re) str)
-              (not (string-match-p (car re) str)))))
-    res))
-
-(defvar ivy--regex-hash
-  (make-hash-table :test #'equal)
-  "Store pre-computed regex.")
-
-(defun ivy--split (str)
-  "Split STR into list of substrings bounded by spaces.
-Single spaces act as splitting points.  Consecutive spaces
-\"quote\" their preceding spaces, i.e., guard them from being
-split.  This allows the literal interpretation of N spaces by
-inputting N+1 spaces.  Any substring not constituting a valid
-regexp is passed to `regexp-quote'."
-  (let ((len (length str))
-        start0
-        (start1 0)
-        res s
-        match-len)
-    (while (and (string-match " +" str start1)
-                (< start1 len))
-      (if (and (> (match-beginning 0) 2)
-               (string= "[^" (substring
-                              str
-                              (- (match-beginning 0) 2)
-                              (match-beginning 0))))
-          (progn
-            (setq start0 start1)
-            (setq start1 (match-end 0)))
-        (setq match-len (- (match-end 0) (match-beginning 0)))
-        (if (= match-len 1)
-            (progn
-              (when start0
-                (setq start1 start0)
-                (setq start0 nil))
-              (push (substring str start1 (match-beginning 0)) res)
-              (setq start1 (match-end 0)))
-          (setq str (replace-match
-                     (make-string (1- match-len) ?\ )
-                     nil nil str))
-          (setq start0 (or start0 start1))
-          (setq start1 (1- (match-end 0))))))
-    (if start0
-        (push (substring str start0) res)
-      (setq s (substring str start1))
-      (unless (= (length s) 0)
-        (push s res)))
-    (mapcar #'ivy--regex-or-literal (nreverse res))))
-
-(defun ivy--regex (str &optional greedy)
-  "Re-build regex pattern from STR in case it has a space.
-When GREEDY is non-nil, join words in a greedy way."
-  (let ((hashed (unless greedy
-                  (gethash str ivy--regex-hash))))
-    (if hashed
-        (prog1 (cdr hashed)
-          (setq ivy--subexps (car hashed)))
-      (when (string-match "\\([^\\]\\|^\\)\\\\$" str)
-        (setq str (substring str 0 -1)))
-      (cdr (puthash str
-                    (let ((subs (ivy--split str)))
-                      (if (= (length subs) 1)
-                          (cons
-                           (setq ivy--subexps 0)
-                           (car subs))
-                        (cons
-                         (setq ivy--subexps (length subs))
-                         (mapconcat
-                          (lambda (x)
-                            (if (string-match "\\`\\\\([^?].*\\\\)\\'" x)
-                                x
-                              (format "\\(%s\\)" x)))
-                          subs
-                          (if greedy
-                              ".*"
-                            ".*?")))))
-                    ivy--regex-hash)))))
-
-(defun ivy--legal-regex-p (str)
-  "Return t if STR is valid regular expression."
-  (condition-case nil
-      (progn
-        (string-match-p str "")
-        t)
-    (invalid-regexp nil)))
-
-(defun ivy--regex-or-literal (str)
-  "If STR isn't a legal regex, escape it."
-  (if (ivy--legal-regex-p str) str (regexp-quote str)))
-
-(defun ivy--split-negation (str)
-  "Split STR into text before and after ! delimiter.
-Do not split if the delimiter is escaped as \\!.
-
-Assumes there is at most one unescaped delimiter and discards
-text after delimiter if it is empty.  Modifies match data."
-  (unless (string= str "")
-    (let ((delim "\\(?:\\`\\|[^\\]\\)\\(!\\)"))
-      (mapcar (lambda (split)
-                ;; Store "\!" as "!".
-                (replace-regexp-in-string "\\\\!" "!" split t t))
-              (if (string-match delim str)
-                  ;; Ignore everything past first unescaped ! rather than
-                  ;; crashing.  We can't warn or error because the minibuffer is
-                  ;; already active.
-                  (let* ((i (match-beginning 1))
-                         (j (and (string-match delim str (1+ i))
-                                 (match-beginning 1)))
-                         (neg (substring str (1+ i) j)))
-                    (cons (substring str 0 i)
-                          (and (not (string= neg ""))
-                               (list neg))))
-                (list str))))))
-
-(defun ivy--split-spaces (str)
-  "Split STR on spaces, unless they're preceded by \\.
-No unescaped spaces are left in the output.  Any substring not
-constituting a valid regexp is passed to `regexp-quote'."
-  (when str
-    (let ((i 0) ; End of last search.
-          (j 0) ; End of last delimiter.
-          parts)
-      (while (string-match "\\(\\\\ \\)\\| +" str i)
-        (setq i (match-end 0))
-        (if (not (match-beginning 1))
-            ;; Unescaped space(s).
-            (let ((delim (match-beginning 0)))
-              (when (< j delim)
-                (push (substring str j delim) parts))
-              (setq j i))
-          ;; Store "\ " as " ".
-          (setq str (replace-match " " t t str 1))
-          (setq i (1- i))))
-      (when (< j (length str))
-        (push (substring str j) parts))
-      (mapcar #'ivy--regex-or-literal (nreverse parts)))))
-
-(defun ivy--regex-ignore-order (str)
-  "Re-build regex from STR by splitting at spaces and using ! for negation.
-
-Examples:
-foo          -> matches \"foo\"
-foo bar      -> matches if both \"foo\" and \"bar\" match (any order)
-foo !bar     -> matches if \"foo\" matches and \"bar\" does not match
-foo !bar baz -> matches if \"foo\" matches and neither \"bar\" nor \"baz\" match
-foo[a-z]     -> matches \"foo[a-z]\"
-
-Escaping examples:
-foo\!bar -> matches \"foo!bar\"
-foo\ bar -> matches \"foo bar\"
-
-Returns a list suitable for `ivy-re-match'."
-  (let* (regex-parts
-         (raw-parts (ivy--split-negation str)))
-    (dolist (part (ivy--split-spaces (car raw-parts)))
-      (push (cons part t) regex-parts))
-    (when (cdr raw-parts)
-      (dolist (part (ivy--split-spaces (cadr raw-parts)))
-        (push (cons part nil) regex-parts)))
-    (if regex-parts (nreverse regex-parts)
-      "")))
-
-(defun ivy--regex-plus (str)
-  "Build a regex sequence from STR.
-Spaces are wild card characters, everything before \"!\" should
-match.  Everything after \"!\" should not match."
-  (let ((parts (ivy--split-negation str)))
-    (cl-case (length parts)
-      (0
-       "")
-      (1
-       (if (string= (substring str 0 1) "!")
-           (list (cons "" t)
-                 (list (ivy--regex (car parts))))
-         (ivy--regex (car parts))))
-      (2
-       (cons
-        (cons (ivy--regex (car parts)) t)
-        (mapcar #'list (split-string (cadr parts) " " t))))
-      (t (error "Unexpected: use only one !")))))
-
-(defun ivy--regex-fuzzy (str)
-  "Build a regex sequence from STR.
-Insert .* between each char."
-  (if (string-match "\\`\\(\\^?\\)\\(.*?\\)\\(\\$?\\)\\'" str)
-      (prog1
-          (concat (match-string 1 str)
-                  (mapconcat
-                   (lambda (x)
-                     (format "\\(%s\\)" (regexp-quote (string x))))
-                   (string-to-list (match-string 2 str))
-                   ".*?")
-                  (match-string 3 str))
-        (setq ivy--subexps (length (match-string 2 str))))
-    str))
-
-(defcustom ivy-fixed-height-minibuffer nil
-  "When non nil, fix the height of the minibuffer during ivy completion.
-This effectively sets the minimum height at this level to `ivy-height' and
-tries to ensure that it does not change depending on the number of candidates."
-  :group 'ivy
-  :type 'boolean)
-
-;;** Rest
-(defcustom ivy-truncate-lines t
-  "Minibuffer setting for `truncate-lines'."
-  :type 'boolean)
-
-(defun ivy--minibuffer-setup ()
-  "Setup ivy completion in the minibuffer."
-  (setq-local mwheel-scroll-up-function 'ivy-next-line)
-  (setq-local mwheel-scroll-down-function 'ivy-previous-line)
-  (setq-local completion-show-inline-help nil)
-  (setq-local minibuffer-default-add-function
-              (lambda ()
-                (list ivy--default)))
-  (setq-local inhibit-field-text-motion nil)
-  (when (display-graphic-p)
-    (setq truncate-lines ivy-truncate-lines))
-  (setq-local max-mini-window-height ivy-height)
-  (if (and ivy-fixed-height-minibuffer
-           (not (eq (ivy-state-caller ivy-last) 'ivy-completion-in-region)))
-      (set-window-text-height (selected-window)
-                              (+ ivy-height
-                                 (if ivy-add-newline-after-prompt
-                                     1
-                                   0)))
-    (when ivy-add-newline-after-prompt
-      (set-window-text-height (selected-window) 2)))
-  (add-hook 'post-command-hook #'ivy--queue-exhibit nil t)
-  ;; show completions with empty input
-  (ivy--exhibit))
-
-(defun ivy--input ()
-  "Return the current minibuffer input."
-  ;; assume one-line minibuffer input
-  (buffer-substring-no-properties
-   (minibuffer-prompt-end)
-   (line-end-position)))
-
-(defun ivy--cleanup ()
-  "Delete the displayed completion candidates."
-  (save-excursion
-    (goto-char (minibuffer-prompt-end))
-    (delete-region (line-end-position) (point-max))))
-
-(defun ivy-cleanup-string (str)
-  "Remove unwanted text properties from STR."
-  (remove-list-of-text-properties 0 (length str) '(field) str)
-  str)
-
-(defvar ivy-set-prompt-text-properties-function
-  'ivy-set-prompt-text-properties-default
-  "Function to set the text properties of the default ivy prompt.
-Called with two arguments, PROMPT and STD-PROPS.
-The returned value should be the updated PROMPT.")
-
-(defun ivy-set-prompt-text-properties-default (prompt std-props)
-  "Set text properties of PROMPT.
-STD-PROPS is a property list containing the default text properties."
-  (ivy--set-match-props prompt "confirm"
-                        `(face ivy-confirm-face ,@std-props))
-  (ivy--set-match-props prompt "match required"
-                        `(face ivy-match-required-face ,@std-props))
-  prompt)
-
-(defun ivy-prompt ()
-  "Return the current prompt."
-  (let ((fn (plist-get ivy--prompts-list (ivy-state-caller ivy-last))))
-    (if fn
-        (condition-case nil
-            (funcall fn)
-          (error
-           (warn "function set by `ivy-set-prompt' should take 0 args")
-           ;; old behavior
-           (funcall fn (ivy-state-prompt ivy-last))))
-      ivy--prompt)))
-
-(defun ivy--insert-prompt ()
-  "Update the prompt according to `ivy--prompt'."
-  (when (setq ivy--prompt (ivy-prompt))
-    (unless (memq this-command '(ivy-done ivy-alt-done ivy-partial-or-done
-                                 counsel-find-symbol))
-      (setq ivy--prompt-extra ""))
-    (let (head tail)
-      (if (string-match "\\(.*?\\)\\(:? ?\\)\\'" ivy--prompt)
-          (progn
-            (setq head (match-string 1 ivy--prompt))
-            (setq tail (match-string 2 ivy--prompt)))
-        (setq head ivy--prompt)
-        (setq tail ""))
-      (let ((inhibit-read-only t)
-            (std-props '(front-sticky t rear-nonsticky t field t read-only t))
-            (n-str
-             (concat
-              (if (and (bound-and-true-p minibuffer-depth-indicate-mode)
-                       (> (minibuffer-depth) 1))
-                  (format "[%d] " (minibuffer-depth))
-                "")
-              (concat
-               (if (string-match "%d.*%d" ivy-count-format)
-                   (format head
-                           (1+ ivy--index)
-                           (or (and (ivy-state-dynamic-collection ivy-last)
-                                    ivy--full-length)
-                               ivy--length))
-                 (format head
-                         (or (and (ivy-state-dynamic-collection ivy-last)
-                                  ivy--full-length)
-                             ivy--length)))
-               ivy--prompt-extra
-               tail)))
-            (d-str (if ivy--directory
-                       (abbreviate-file-name ivy--directory)
-                     "")))
-        (save-excursion
-          (goto-char (point-min))
-          (delete-region (point-min) (minibuffer-prompt-end))
-          (let ((len-n (length n-str))
-                (len-d (length d-str))
-                (ww (window-width)))
-            (setq n-str
-                  (cond ((> (+ len-n len-d) ww)
-                         (concat n-str "\n" d-str "\n"))
-                        ((> (+ len-n len-d (length ivy-text)) ww)
-                         (concat n-str d-str "\n"))
-                        (t
-                         (concat n-str d-str)))))
-          (when ivy-add-newline-after-prompt
-            (setq n-str (concat n-str "\n")))
-          (let ((regex (format "\\([^\n]\\{%d\\}\\)[^\n]" (window-width))))
-            (while (string-match regex n-str)
-              (setq n-str (replace-match
-                           (concat (match-string 1 n-str) "\n")
-                           nil t n-str 1))))
-          (set-text-properties 0 (length n-str)
-                               `(face minibuffer-prompt ,@std-props)
-                               n-str)
-          (setq n-str (funcall ivy-set-prompt-text-properties-function
-                               n-str std-props))
-          (insert n-str))
-        ;; Mark prompt as selected if the user moves there or it is the only
-        ;; option left.  Since the user input stays put, we have to manually
-        ;; remove the face as well.
-        (when (ivy--prompt-selectable-p)
-          (if (or (= ivy--index -1)
-                  (= ivy--length 0))
-              (ivy-add-face-text-property
-               (minibuffer-prompt-end) (line-end-position) 'ivy-prompt-match)
-            (remove-list-of-text-properties
-             (minibuffer-prompt-end) (line-end-position) '(face))))
-        ;; get out of the prompt area
-        (constrain-to-field nil (point-max))))))
-
-(defun ivy--set-match-props (str match props &optional subexp)
-  "Set text properties of STR that match MATCH to PROPS.
-SUBEXP is a number which specifies the regexp group to use.
-If nil, the text properties are applied to the whole match."
-  (when (null subexp)
-    (setq subexp 0))
-  (when (string-match match str)
-    (set-text-properties
-     (match-beginning subexp)
-     (match-end subexp)
-     props
-     str)))
-
-(defun ivy--sort-maybe (collection)
-  "Sort COLLECTION if needed."
-  (let ((sort (ivy-state-sort ivy-last)))
-    (if (and sort
-             (or (functionp sort)
-                 (functionp (setq sort (ivy--sort-function
-                                        (ivy-state-collection ivy-last))))))
-        (sort (copy-sequence collection) sort)
-      collection)))
-
-(defcustom ivy-magic-slash-non-match-action 'ivy-magic-slash-non-match-cd-selected
-  "Action to take when a slash is added to the end of a non existing directory.
-Possible choices are 'ivy-magic-slash-non-match-cd-selected,
-'ivy-magic-slash-non-match-create, or nil"
-  :type '(choice
-          (const :tag "Use currently selected directory"
-           ivy-magic-slash-non-match-cd-selected)
-          (const :tag "Create and use new directory"
-           ivy-magic-slash-non-match-create)
-          (const :tag "Do nothing"
-           nil)))
-
-(defun ivy--create-and-cd (dir)
-  "When completing file names, create directory DIR and move there."
-  (make-directory dir)
-  (ivy--cd dir))
-
-(defun ivy--magic-file-slash ()
-  "Handle slash when completing file names."
-  (when (or (and (eq this-command 'self-insert-command)
-                 (eolp))
-            (eq this-command 'ivy-partial-or-done))
-    (cond ((member ivy-text ivy--all-candidates)
-           (ivy--cd (expand-file-name ivy-text ivy--directory)))
-          ((string-match "//\\'" ivy-text)
-           (if (and default-directory
-                    (string-match "\\`[[:alpha:]]:/" default-directory))
-               (ivy--cd (match-string 0 default-directory))
-             (ivy--cd "/")))
-          ((string-match "\\`/ssh:" ivy-text)
-           (ivy--cd (file-name-directory ivy-text)))
-          ((string-match "[[:alpha:]]:/\\'" ivy-text)
-           (let ((drive-root (match-string 0 ivy-text)))
-             (when (file-exists-p drive-root)
-               (ivy--cd drive-root))))
-          ((and (file-exists-p ivy-text)
-                (not (string= ivy-text "/"))
-                (file-directory-p ivy-text))
-           (ivy--cd (expand-file-name ivy-text)))
-          ((and (or (> ivy--index 0)
-                    (= ivy--length 1)
-                    (not (string= ivy-text "/")))
-                (let ((default-directory ivy--directory))
-                  (and
-                   (not (equal (ivy-state-current ivy-last) ""))
-                   (file-directory-p (ivy-state-current ivy-last))
-                   (file-exists-p (ivy-state-current ivy-last)))))
-           (cond
-             ((or (eq ivy-magic-slash-non-match-action 'ivy-magic-slash-non-match-cd-selected)
-                  (eq this-command 'ivy-partial-or-done))
-              (ivy--cd
-               (expand-file-name (ivy-state-current ivy-last) ivy--directory)))
-
-             ((and (eq ivy-magic-slash-non-match-action 'ivy-magic-slash-non-match-create)
-                   (not (string= ivy-text "/")))
-              (ivy--create-and-cd (expand-file-name ivy-text ivy--directory)))))
-          (t
-           (when (and
-                  (eq ivy-magic-slash-non-match-action 'ivy-magic-slash-non-match-create)
-                  (not (string= ivy-text "/")))
-             (ivy--create-and-cd (expand-file-name ivy-text ivy--directory)))))))
-
-(defcustom ivy-magic-tilde t
-  "When non-nil, ~ will move home when selecting files.
-Otherwise, ~/ will move home."
-  :type 'boolean)
-
-(defcustom ivy-dynamic-exhibit-delay-ms 0
-  "Delay in ms before dynamic collections are refreshed"
-  :type 'integer)
-
-(defvar ivy--exhibit-timer nil)
-
-(defun ivy--queue-exhibit ()
-  "Insert Ivy completions display, possibly after a timeout for
-dynamic collections.
-Should be run via minibuffer `post-command-hook'."
-  (if (and (> ivy-dynamic-exhibit-delay-ms 0)
-           (ivy-state-dynamic-collection ivy-last))
-      (progn
-        (when ivy--exhibit-timer (cancel-timer ivy--exhibit-timer))
-        (setq ivy--exhibit-timer
-              (run-with-timer
-               (/ ivy-dynamic-exhibit-delay-ms 1000.0)
-               nil
-               'ivy--exhibit)))
-    (ivy--exhibit)))
-
-(defun ivy--exhibit ()
-  "Insert Ivy completions display.
-Should be run via minibuffer `post-command-hook'."
-  (when (memq 'ivy--queue-exhibit post-command-hook)
-    (let ((inhibit-field-text-motion nil))
-      (constrain-to-field nil (point-max)))
-    (setq ivy-text (ivy--input))
-    (if (ivy-state-dynamic-collection ivy-last)
-        ;; while-no-input would cause annoying
-        ;; "Waiting for process to die...done" message interruptions
-        (let ((inhibit-message t))
-          (unless (equal ivy--old-text ivy-text)
-            (while-no-input
-              (setq ivy--all-candidates
-                    (ivy--sort-maybe
-                     (funcall (ivy-state-collection ivy-last) ivy-text)))
-              (setq ivy--old-text ivy-text)))
-          (when (or ivy--all-candidates
-                    (not (get-process " *counsel*")))
-            (ivy--insert-minibuffer
-             (ivy--format ivy--all-candidates))))
-      (cond (ivy--directory
-             (cond ((or (string= "~/" ivy-text)
-                        (and (string= "~" ivy-text)
-                             ivy-magic-tilde))
-                    (ivy--cd (expand-file-name "~/")))
-                   ((string-match "/\\'" ivy-text)
-                    (ivy--magic-file-slash))))
-            ((eq (ivy-state-collection ivy-last) #'internal-complete-buffer)
-             (when (or (and (string-match "\\` " ivy-text)
-                            (not (string-match "\\` " ivy--old-text)))
-                       (and (string-match "\\` " ivy--old-text)
-                            (not (string-match "\\` " ivy-text))))
-               (setq ivy--all-candidates
-                     (if (and (> (length ivy-text) 0)
-                              (eq (aref ivy-text 0)
-                                  ?\ ))
-                         (ivy--buffer-list " ")
-                       (ivy--buffer-list "" ivy-use-virtual-buffers)))
-               (setq ivy--old-re nil))))
-      (ivy--insert-minibuffer
-       (with-current-buffer (ivy-state-buffer ivy-last)
-         (ivy--format
-          (ivy--filter ivy-text ivy--all-candidates))))
-      (setq ivy--old-text ivy-text))))
-
-(defun ivy-display-function-fallback (str)
-  (let ((buffer-undo-list t))
-    (save-excursion
-      (forward-line 1)
-      (insert str))))
-
-(defun ivy--insert-minibuffer (text)
-  "Insert TEXT into minibuffer with appropriate cleanup."
-  (let ((resize-mini-windows nil)
-        (update-fn (ivy-state-update-fn ivy-last))
-        (old-mark (marker-position (mark-marker)))
-        deactivate-mark)
-    (ivy--cleanup)
-    (when update-fn
-      (funcall update-fn))
-    (ivy--insert-prompt)
-    ;; Do nothing if while-no-input was aborted.
-    (when (stringp text)
-      (if ivy-display-function
-          (funcall ivy-display-function text)
-        (ivy-display-function-fallback text)))
-    (ivy--resize-minibuffer-to-fit)
-    ;; prevent region growing due to text remove/add
-    (when (region-active-p)
-      (set-mark old-mark))))
-
-(defun ivy--resize-minibuffer-to-fit ()
-  "Resize the minibuffer window size to fit the text in the minibuffer."
-  (unless (frame-root-window-p (minibuffer-window))
-    (with-selected-window (minibuffer-window)
-      (if (fboundp 'window-text-pixel-size)
-          (let ((text-height (cdr (window-text-pixel-size)))
-                (body-height (window-body-height nil t)))
-            (when (> text-height body-height)
-              ;; Note: the size increment needs to be at least
-              ;; frame-char-height, otherwise resizing won't do
-              ;; anything.
-              (let ((delta (max (- text-height body-height)
-                                (frame-char-height))))
-                (window-resize nil delta nil t t))))
-        (let ((text-height (count-screen-lines))
-              (body-height (window-body-height)))
-          (when (> text-height body-height)
-            (window-resize nil (- text-height body-height) nil t)))))))
-
-(defun ivy--add-face (str face)
-  "Propertize STR with FACE."
-  (let ((len (length str)))
-    (condition-case nil
-        (progn
-          (colir-blend-face-background 0 len face str)
-          (let ((foreground (face-foreground face)))
-            (when foreground
-              (ivy-add-face-text-property
-               0 len (list :foreground foreground) str))))
-      (error
-       (ignore-errors
-         (font-lock-append-text-property 0 len 'face face str)))))
-  str)
-
-(declare-function flx-make-string-cache "ext:flx")
-(declare-function flx-score "ext:flx")
-
-(defvar ivy--flx-cache nil)
-
-(eval-after-load 'flx
-  '(setq ivy--flx-cache (flx-make-string-cache)))
-
-(defun ivy-toggle-case-fold ()
-  "Toggle `case-fold-search' for Ivy operations.
-
-Instead of modifying `case-fold-search' directly, this command
-toggles `ivy-case-fold-search', which can take on more values
-than the former, between nil and either `auto' or t.  See
-`ivy-case-fold-search-default' for the meaning of these values.
-
-In any Ivy completion session, the case folding starts with
-`ivy-case-fold-search-default'."
-  (interactive)
-  (setq ivy-case-fold-search
-        (and (not ivy-case-fold-search)
-             (or ivy-case-fold-search-default 'auto)))
-  ;; Reset cache so that the candidate list updates.
-  (setq ivy--old-re nil))
-
-(defun ivy--re-filter (re candidates &optional mkpred)
-  "Return all RE matching CANDIDATES.
-RE is a list of cons cells, with a regexp car and a boolean cdr.
-When the cdr is t, the car must match.
-Otherwise, the car must not match."
-  (ignore-errors
-    (dolist (re (if (stringp re) (list (cons re t)) re))
-      (let* ((re-str (car re))
-             (pred
-              (if mkpred
-                  (funcall mkpred re-str)
-                (lambda (x) (string-match-p re-str x)))))
-        (setq candidates
-              (cl-remove nil candidates
-                         (if (cdr re) :if-not :if)
-                         pred))))
-    candidates))
-
-(defun ivy--filter (name candidates)
-  "Return all items that match NAME in CANDIDATES.
-CANDIDATES are assumed to be static."
-  (let ((re (funcall ivy--regex-function name)))
-    (if (and
-         ivy--old-re
-         ivy--old-cands
-         (equal re ivy--old-re))
-        ;; quick caching for "C-n", "C-p" etc.
-        ivy--old-cands
-      (let* ((re-str (if (listp re) (caar re) re))
-             (matcher (ivy-state-matcher ivy-last))
-             (case-fold-search (ivy--case-fold-p name))
-             (cands (cond
-                      (matcher
-                       (funcall matcher re candidates))
-                      ((and ivy--old-re
-                            (stringp re)
-                            (stringp ivy--old-re)
-                            (not (string-match-p "\\\\" ivy--old-re))
-                            (not (equal ivy--old-re ""))
-                            (memq (cl-search
-                                   (if (string-match-p "\\\\)\\'" ivy--old-re)
-                                       (substring ivy--old-re 0 -2)
-                                     ivy--old-re)
-                                   re)
-                                  '(0 2)))
-                       (ignore-errors
-                         (cl-remove-if-not
-                          (lambda (x) (string-match-p re x))
-                          ivy--old-cands)))
-                      (t
-                       (ivy--re-filter re candidates)))))
-        (if (memq (cdr (assq (ivy-state-caller ivy-last)
-                             ivy-index-functions-alist))
-                  '(ivy-recompute-index-swiper
-                    ivy-recompute-index-swiper-async))
-            (progn
-              (ivy--recompute-index name re-str cands)
-              (setq ivy--old-cands (ivy--sort name cands)))
-          (setq ivy--old-cands (ivy--sort name cands))
-          (ivy--recompute-index name re-str ivy--old-cands))
-        (setq ivy--old-re re)
-        ivy--old-cands))))
-
-(defun ivy--set-candidates (x)
-  "Update `ivy--all-candidates' with X."
-  (let (res)
-    (dolist (source ivy--extra-candidates)
-      (if (equal source '(original-source))
-          (if (null res)
-              (setq res x)
-            (setq res (append x res)))
-        (setq ivy--old-re nil)
-        (setq res (append
-                   (ivy--filter ivy-text (cadr source))
-                   res))))
-    (setq ivy--all-candidates res)))
-
-(defcustom ivy-sort-matches-functions-alist
-  '((t . nil)
-    (ivy-switch-buffer . ivy-sort-function-buffer))
-  "An alist of functions for sorting matching candidates.
-
-Unlike `ivy-sort-functions-alist', which is used to sort the
-whole collection only once, this alist of functions are used to
-sort only matching candidates after each change in input.
-
-The alist KEY is either a collection function or t to match
-previously unmatched collection functions.
-
-The alist VAL is a sorting function with the signature of
-`ivy--prefix-sort'."
-  :type '(alist
-          :key-type (choice
-                     (const :tag "Fall-through" t)
-                     (symbol :tag "Collection"))
-          :value-type
-          (choice
-           (const :tag "Don't sort" nil)
-           (const :tag "Put prefix matches ahead" ivy--prefix-sort)
-           (function :tag "Custom sort function"))))
-
-(defun ivy--sort-files-by-date (_name candidates)
-  "Re-sort CANDIDATES according to file modification date."
-  (let ((default-directory ivy--directory))
-    (sort (copy-sequence candidates) #'file-newer-than-file-p)))
-
-(defvar ivy--flx-featurep (require 'flx nil 'noerror))
-
-(defun ivy--sort (name candidates)
-  "Re-sort candidates by NAME.
-All CANDIDATES are assumed to match NAME."
-  (let ((key (or (ivy-state-caller ivy-last)
-                 (when (functionp (ivy-state-collection ivy-last))
-                   (ivy-state-collection ivy-last))
-                 this-command))
-        fun)
-    (cond ((and ivy--flx-featurep
-                (eq ivy--regex-function 'ivy--regex-fuzzy))
-           (ivy--flx-sort name candidates))
-          ((setq fun (ivy-alist-setting ivy-sort-matches-functions-alist key))
-           (funcall fun name candidates))
-          (t
-           candidates))))
-
-(defun ivy--prefix-sort (name candidates)
-  "Re-sort candidates by NAME.
-All CANDIDATES are assumed to match NAME.
-Prefix matches to NAME are put ahead of the list."
-  (if (or (string-match-p "\\`\\^" name) (string= name ""))
-      candidates
-    (let ((re-prefix (concat "\\`" (funcall ivy--regex-function name)))
-          res-prefix
-          res-noprefix)
-      (dolist (s candidates)
-        (if (string-match-p re-prefix s)
-            (push s res-prefix)
-          (push s res-noprefix)))
-      (nconc
-       (nreverse res-prefix)
-       (nreverse res-noprefix)))))
-
-(defvar ivy--virtual-buffers nil
-  "Store the virtual buffers alist.")
-
-(defun ivy-generic-regex-to-str (re)
-  "Transform RE to a string.
-
-Functions like `ivy--regex-ignore-order' return a cons list.
-This function extracts a string from the cons list."
-  (if (consp re) (caar re) re))
-
-(defun ivy-sort-function-buffer (name candidates)
-  "Re-sort candidates by NAME.
-CANDIDATES is a list of buffer names each containing NAME.
-Sort open buffers before virtual buffers, and prefix matches
-before substring matches."
-  (if (or (string-match-p "\\`\\^" name) (string= name ""))
-      candidates
-    (let* ((base-re (ivy-generic-regex-to-str (funcall ivy--regex-function name)))
-           (re-prefix (concat "\\`\\*" base-re))
-           res-prefix
-           res-noprefix
-           res-virtual-prefix
-           res-virtual-noprefix)
-      (unless (cl-find-if (lambda (s) (string-match-p re-prefix s)) candidates)
-        (setq re-prefix (concat "\\`" base-re)))
-      (dolist (s candidates)
-        (cond
-          ((and (assoc s ivy--virtual-buffers) (string-match-p re-prefix s))
-           (push s res-virtual-prefix))
-          ((assoc s ivy--virtual-buffers)
-           (push s res-virtual-noprefix))
-          ((string-match-p re-prefix s)
-           (push s res-prefix))
-          (t
-           (push s res-noprefix))))
-      (nconc
-       (nreverse res-prefix)
-       (nreverse res-noprefix)
-       (nreverse res-virtual-prefix)
-       (nreverse res-virtual-noprefix)))))
-
-(defun ivy--recompute-index (name re-str cands)
-  "Recompute index of selected candidate matching NAME.
-RE-STR is the regexp, CANDS are the current candidates."
-  (let ((caller (ivy-state-caller ivy-last))
-        (func (or (ivy-alist-setting ivy-index-functions-alist)
-                  #'ivy-recompute-index-zero))
-        (case-fold-search (ivy--case-fold-p name))
-        (preselect (ivy-state-preselect ivy-last))
-        (current (ivy-state-current ivy-last))
-        (empty (string= name "")))
-    (unless (eq this-command 'ivy-resume)
-      (ivy-set-index
-       (or
-        (cl-position (if (= (string-to-char name) ?^)
-                         (substring name 1)
-                       name)
-                     cands
-                     :test #'ivy--case-fold-string=)
-        (and ivy--directory
-             (cl-position (concat re-str "/")
-                          cands
-                          :test #'ivy--case-fold-string=))
-        (and (eq caller 'ivy-switch-buffer)
-             (not empty)
-             0)
-        (and (not empty)
-             (not (and ivy--flx-featurep
-                       (eq ivy--regex-function 'ivy--regex-fuzzy)
-                       ;; Limit to 200 candidates
-                       (null (nthcdr 200 cands))))
-             ;; If there was a preselected candidate, don't try to
-             ;; keep it selected even if the regexp still matches it.
-             ;; See issue #1563.  See also `ivy--preselect-index',
-             ;; which this logic roughly mirrors.
-             (not (or
-                   (and (integerp preselect)
-                        (= ivy--index preselect))
-                   (equal current preselect)
-                   (and (stringp preselect)
-                        (stringp current)
-                        (string-match-p preselect current))))
-             ivy--old-cands
-             (cl-position current cands :test #'equal))
-        (funcall func re-str cands))))
-    (when (or empty (string= name "^"))
-      (ivy-set-index
-       (or (ivy--preselect-index preselect cands)
-           ivy--index)))))
-
-(defun ivy-recompute-index-swiper (_re-str cands)
-  "Recompute index of selected candidate when using `swiper'.
-CANDS are the current candidates."
-  (condition-case nil
-      (let ((tail (nthcdr ivy--index ivy--old-cands))
-            idx)
-        (if (and tail ivy--old-cands (not (equal "^" ivy--old-re)))
-            (progn
-              (while (and tail (null idx))
-                ;; Compare with eq to handle equal duplicates in cands
-                (setq idx (cl-position (pop tail) cands)))
-              (or
-               idx
-               (1- (length cands))))
-          (if ivy--old-cands
-              ivy--index
-            ;; already in ivy-state-buffer
-            (let ((n (line-number-at-pos))
-                  (res 0)
-                  (i 0))
-              (dolist (c cands)
-                (when (eq n (read (get-text-property 0 'swiper-line-number c)))
-                  (setq res i))
-                (cl-incf i))
-              res))))
-    (error 0)))
-
-(defun ivy-recompute-index-swiper-async (_re-str cands)
-  "Recompute index of selected candidate when using `swiper' asynchronously.
-CANDS are the current candidates."
-  (if (null ivy--old-cands)
-      (let ((ln (with-ivy-window
-                  (line-number-at-pos))))
-        (or
-         ;; closest to current line going forwards
-         (cl-position-if (lambda (x)
-                           (>= (string-to-number x) ln))
-                         cands)
-         ;; closest to current line going backwards
-         (1- (length cands))))
-    (let ((tail (nthcdr ivy--index ivy--old-cands))
-          idx)
-      (if (and tail ivy--old-cands (not (equal "^" ivy--old-re)))
-          (progn
-            (while (and tail (null idx))
-              ;; Compare with `equal', since the collection is re-created
-              ;; each time with `split-string'
-              (setq idx (cl-position (pop tail) cands :test #'equal)))
-            (or idx 0))
-        ivy--index))))
-
-(defun ivy-recompute-index-zero (_re-str _cands)
-  "Recompute index of selected candidate.
-This function serves as a fallback when nothing else is available."
-  0)
-
-(defcustom ivy-minibuffer-faces
-  '(ivy-minibuffer-match-face-1
-    ivy-minibuffer-match-face-2
-    ivy-minibuffer-match-face-3
-    ivy-minibuffer-match-face-4)
-  "List of `ivy' faces for minibuffer group matches."
-  :type '(repeat :tag "Faces"
-          (choice
-           (const ivy-minibuffer-match-face-1)
-           (const ivy-minibuffer-match-face-2)
-           (const ivy-minibuffer-match-face-3)
-           (const ivy-minibuffer-match-face-4)
-           (face :tag "Other face"))))
-
-(defvar ivy-flx-limit 200
-  "Used to conditionally turn off flx sorting.
-
-When the amount of matching candidates exceeds this limit, then
-no sorting is done.")
-
-(defun ivy--flx-propertize (x)
-  "X is (cons (flx-score STR ...) STR)."
-  (let ((str (copy-sequence (cdr x)))
-        (i 0)
-        (last-j -2))
-    (dolist (j (cdar x))
-      (unless (eq j (1+ last-j))
-        (cl-incf i))
-      (setq last-j j)
-      (ivy-add-face-text-property
-       j (1+ j)
-       (nth (1+ (mod (+ i 2) (1- (length ivy-minibuffer-faces))))
-            ivy-minibuffer-faces)
-       str))
-    str))
-
-(defun ivy--flx-sort (name cands)
-  "Sort according to closeness to string NAME the string list CANDS."
-  (condition-case nil
-      (let* ((bolp (= (string-to-char name) ?^))
-             ;; An optimized regex for fuzzy matching
-             ;; "abc" โ†’ "^[^a]*a[^b]*b[^c]*c"
-             (fuzzy-regex (concat "\\`"
-                                  (and bolp (regexp-quote (substring name 1 2)))
-                                  (mapconcat
-                                   (lambda (x)
-                                     (setq x (char-to-string x))
-                                     (concat "[^" x "]*" (regexp-quote x)))
-                                   (if bolp (substring name 2) name)
-                                   "")))
-             ;; Strip off the leading "^" for flx matching
-             (flx-name (if bolp (substring name 1) name))
-             cands-left
-             cands-to-sort)
-
-        ;; Filter out non-matching candidates
-        (dolist (cand cands)
-          (when (string-match-p fuzzy-regex cand)
-            (push cand cands-left)))
-
-        ;; pre-sort the candidates by length before partitioning
-        (setq cands-left (cl-sort cands-left #'< :key #'length))
-
-        ;; partition the candidates into sorted and unsorted groups
-        (dotimes (_ (min (length cands-left) ivy-flx-limit))
-          (push (pop cands-left) cands-to-sort))
-
-        (nconc
-         ;; Compute all of the flx scores in one pass and sort
-         (mapcar #'car
-                 (sort (mapcar
-                        (lambda (cand)
-                          (cons cand
-                                (car (flx-score cand flx-name ivy--flx-cache))))
-                        cands-to-sort)
-                       (lambda (c1 c2)
-                         ;; Break ties by length
-                         (if (/= (cdr c1) (cdr c2))
-                             (> (cdr c1)
-                                (cdr c2))
-                           (< (length (car c1))
-                              (length (car c2)))))))
-
-         ;; Add the unsorted candidates
-         cands-left))
-    (error cands)))
-
-(defun ivy--truncate-string (str width)
-  "Truncate STR to WIDTH."
-  (truncate-string-to-width str width nil nil t))
-
-(defun ivy--format-function-generic (selected-fn other-fn cands separator)
-  "Transform candidates into a string for minibuffer.
-SELECTED-FN is called for the selected candidate, OTHER-FN for the others.
-Both functions take one string argument each.  CANDS is a list of candidates
-and SEPARATOR is used to join them."
-  (let ((i -1))
-    (mapconcat
-     (lambda (str)
-       (let ((curr (eq (cl-incf i) ivy--window-index)))
-         (if curr
-             (funcall selected-fn str)
-           (funcall other-fn str))))
-     cands
-     separator)))
-
-(defun ivy-format-function-default (cands)
-  "Transform CANDS into a string for minibuffer."
-  (ivy--format-function-generic
-   (lambda (str)
-     (ivy--add-face str 'ivy-current-match))
-   #'identity
-   cands
-   "\n"))
-
-(defun ivy-format-function-arrow (cands)
-  "Transform CANDS into a string for minibuffer."
-  (ivy--format-function-generic
-   (lambda (str)
-     (concat "> " (ivy--add-face str 'ivy-current-match)))
-   (lambda (str)
-     (concat "  " str))
-   cands
-   "\n"))
-
-(defun ivy-format-function-line (cands)
-  "Transform CANDS into a string for minibuffer."
-  (ivy--format-function-generic
-   (lambda (str)
-     (ivy--add-face (concat str "\n") 'ivy-current-match))
-   (lambda (str)
-     (concat str "\n"))
-   cands
-   ""))
-
-(defalias 'ivy-add-face-text-property
-  (if (fboundp 'add-face-text-property)
-      (lambda (start end face &optional object append)
-        (add-face-text-property start end face append object))
-    (lambda (start end face &optional object append)
-      (funcall (if append
-                   #'font-lock-append-text-property
-                 #'font-lock-prepend-text-property)
-               start end 'face face object)))
-  "Compatibility shim for `add-face-text-property'.
-Fall back on `font-lock-prepend-text-property' in Emacs versions
-prior to 24.4 (`font-lock-append-text-property' when APPEND is
-non-nil).
-Note: The usual last two arguments are flipped for convenience.")
-
-(defun ivy--highlight-ignore-order (str)
-  "Highlight STR, using the ignore-order method."
-  (when (consp ivy--old-re)
-    (let ((i 1))
-      (dolist (re ivy--old-re)
-        (when (string-match (car re) str)
-          (ivy-add-face-text-property
-           (match-beginning 0) (match-end 0)
-           (nth (1+ (mod (+ i 2) (1- (length ivy-minibuffer-faces))))
-                ivy-minibuffer-faces)
-           str))
-        (cl-incf i))))
-  str)
-
-(defun ivy--highlight-fuzzy (str)
-  "Highlight STR, using the fuzzy method."
-  (if ivy--flx-featurep
-      (let ((flx-name (if (string-match-p "\\`\\^" ivy-text)
-                          (substring ivy-text 1)
-                        ivy-text)))
-        (ivy--flx-propertize
-         (cons (flx-score str flx-name ivy--flx-cache) str)))
-    (ivy--highlight-default str)))
-
-(defun ivy--highlight-default (str)
-  "Highlight STR, using the default method."
-  (unless ivy--old-re
-    (setq ivy--old-re (funcall ivy--regex-function ivy-text)))
-  (let ((start
-         (if (and (memq (ivy-state-caller ivy-last) ivy-highlight-grep-commands)
-                  (string-match "\\`[^:]+:[^:]+:" str))
-             (match-end 0)
-           0))
-        (regexps
-         (if (listp ivy--old-re)
-             (mapcar #'car (cl-remove-if-not #'cdr ivy--old-re))
-           (list ivy--old-re))))
-    (dolist (re regexps)
-      (ignore-errors
-        (while (and (string-match re str start)
-                    (> (- (match-end 0) (match-beginning 0)) 0))
-          (setq start (match-end 0))
-          (let ((i 0))
-            (while (<= i ivy--subexps)
-              (let ((face
-                     (cond ((zerop ivy--subexps)
-                            (cadr ivy-minibuffer-faces))
-                           ((zerop i)
-                            (car ivy-minibuffer-faces))
-                           (t
-                            (nth (1+ (mod (+ i 2)
-                                          (1- (length ivy-minibuffer-faces))))
-                                 ivy-minibuffer-faces)))))
-                (ivy-add-face-text-property
-                 (match-beginning i) (match-end i)
-                 face str))
-              (cl-incf i)))))))
-  str)
-
-(defun ivy--format-minibuffer-line (str)
-  "Format line STR for use in minibuffer."
-  (let* ((str (ivy-cleanup-string (copy-sequence str)))
-         (str (if (eq ivy-display-style 'fancy)
-                  (funcall ivy--highlight-function str)
-                str))
-         (olen (length str))
-         (annot (plist-get completion-extra-properties :annotation-function)))
-    (add-text-properties
-     0 olen
-     '(mouse-face
-       ivy-minibuffer-match-highlight
-       help-echo
-       (format
-        (if tooltip-mode
-            "mouse-1: %s\nmouse-3: %s"
-          "mouse-1: %s   mouse-3: %s")
-        ivy-mouse-1-tooltip ivy-mouse-3-tooltip))
-     str)
-    (when annot
-      (setq str (concat str (funcall annot str)))
-      (ivy-add-face-text-property
-       olen (length str) 'completions-annotations str))
-    str))
-
-(ivy-set-display-transformer
- 'counsel-find-file 'ivy-read-file-transformer)
-(ivy-set-display-transformer
- 'read-file-name-internal 'ivy-read-file-transformer)
-
-(defun ivy-read-file-transformer (str)
-  "Transform candidate STR when reading files."
-  (if (ivy--dirname-p str)
-      (propertize str 'face 'ivy-subdir)
-    str))
-
-(defun ivy--format (cands)
-  "Return a string for CANDS suitable for display in the minibuffer.
-CANDS is a list of strings."
-  (setq ivy--length (length cands))
-  (when (>= ivy--index ivy--length)
-    (ivy-set-index (max (1- ivy--length) 0)))
-  (if (null cands)
-      (setf (ivy-state-current ivy-last) "")
-    (setf (ivy-state-current ivy-last) (copy-sequence (nth ivy--index cands)))
-    (let* ((half-height (/ ivy-height 2))
-           (start (max 0 (- ivy--index half-height)))
-           (end (min (+ start (1- ivy-height)) ivy--length))
-           (start (max 0 (min start (- end (1- ivy-height)))))
-           (wnd-cands (cl-subseq cands start end))
-           transformer-fn)
-      (setq ivy--window-index (- ivy--index start))
-      (when (setq transformer-fn (ivy-state-display-transformer-fn ivy-last))
-        (with-ivy-window
-          (with-current-buffer (ivy-state-buffer ivy-last)
-            (setq wnd-cands (mapcar transformer-fn wnd-cands)))))
-      (ivy--wnd-cands-to-str wnd-cands))))
-
-(defun ivy--wnd-cands-to-str (wnd-cands)
-  (let ((str (concat "\n"
-                     (funcall ivy-format-function
-                              (mapcar
-                               #'ivy--format-minibuffer-line
-                               wnd-cands)))))
-    (put-text-property 0 (length str) 'read-only nil str)
-    str))
-
-(defvar recentf-list)
-(defvar bookmark-alist)
-
-(defcustom ivy-virtual-abbreviate 'name
-  "The mode of abbreviation for virtual buffer names."
-  :type '(choice
-          (const :tag "Only name" name)
-          (const :tag "Abbreviated path" abbreviate)
-          (const :tag "Full path" full)
-          ;; eventually, uniquify
-          ))
-(declare-function bookmark-maybe-load-default-file "bookmark")
-(declare-function bookmark-get-filename "bookmark")
-
-(defun ivy--virtual-buffers ()
-  "Adapted from `ido-add-virtual-buffers-to-list'."
-  (require 'bookmark)
-  (unless recentf-mode
-    (recentf-mode 1))
-  (let (virtual-buffers)
-    (bookmark-maybe-load-default-file)
-    (dolist (head (append recentf-list
-                          (delete "   - no file -"
-                                  (delq nil (mapcar #'bookmark-get-filename
-                                                    bookmark-alist)))))
-      (let* ((file-name (if (stringp head)
-                            head
-                          (cdr head)))
-             (name (cond ((eq ivy-virtual-abbreviate 'name)
-                          (file-name-nondirectory file-name))
-                         ((eq ivy-virtual-abbreviate 'abbreviate)
-                          (abbreviate-file-name file-name))
-                         (t
-                          (expand-file-name file-name)))))
-        (when (equal name "")
-          (setq name
-                (if (consp head)
-                    (car head)
-                  (file-name-nondirectory (directory-file-name file-name)))))
-        (unless (or (equal name "")
-                    (get-file-buffer file-name)
-                    (assoc name virtual-buffers))
-          (push (cons name file-name) virtual-buffers))))
-    (when virtual-buffers
-      (dolist (comp virtual-buffers)
-        (put-text-property 0 (length (car comp))
-                           'face 'ivy-virtual
-                           (car comp)))
-      (setq ivy--virtual-buffers (nreverse virtual-buffers))
-      (mapcar #'car ivy--virtual-buffers))))
-
-(defcustom ivy-ignore-buffers '("\\` ")
-  "List of regexps or functions matching buffer names to ignore."
-  :type '(repeat (choice regexp function)))
-
-(defvar ivy-switch-buffer-faces-alist '((dired-mode . ivy-subdir)
-                                        (org-mode . org-level-4))
-  "Store face customizations for `ivy-switch-buffer'.
-Each KEY is `major-mode', each VALUE is a face name.")
-
-(defun ivy--buffer-list (str &optional virtual predicate)
-  "Return the buffers that match STR.
-If VIRTUAL is non-nil, add virtual buffers.
-If optional argument PREDICATE is non-nil, use it to test each
-possible match.  See `all-completions' for further information."
-  (delete-dups
-   (nconc
-    (mapcar
-     (lambda (x)
-       (let* ((buf (get-buffer x))
-              (dir (buffer-local-value 'default-directory buf))
-              (face (if (and dir (file-remote-p (abbreviate-file-name dir)))
-                        'ivy-remote
-                      (cdr (assq (buffer-local-value 'major-mode buf)
-                                 ivy-switch-buffer-faces-alist)))))
-         (if face
-             (propertize x 'face face)
-           x)))
-     (all-completions str #'internal-complete-buffer predicate))
-    (and virtual
-         (ivy--virtual-buffers)))))
-
-(defvar ivy-views (and nil
-                       `(("ivy + *scratch* {}"
-                          (vert
-                           (file ,(expand-file-name "ivy.el"))
-                           (buffer "*scratch*")))
-                         ("swiper + *scratch* {}"
-                          (horz
-                           (file ,(expand-file-name "swiper.el"))
-                           (buffer "*scratch*")))))
-  "Store window configurations selectable by `ivy-switch-buffer'.
-
-The default value is given as an example.
-
-Each element is a list of (NAME TREE).  NAME is a string, it's
-recommended to end it with a distinctive snippet e.g. \"{}\" so
-that it's easy to distinguish the window configurations.
-
-TREE is a nested list with the following valid cars:
-- vert: split the window vertically
-- horz: split the window horizontally
-- file: open the specified file
-- buffer: open the specified buffer
-
-TREE can be nested multiple times to have multiple window splits.")
-
-(defun ivy-default-view-name ()
-  "Return default name for new view."
-  (let* ((default-view-name
-          (concat "{} "
-                  (mapconcat #'identity
-                             (sort
-                              (mapcar (lambda (w)
-                                        (let* ((b (window-buffer w))
-                                               (f (buffer-file-name b)))
-                                          (if f
-                                              (file-name-nondirectory f)
-                                            (buffer-name b))))
-                                      (window-list))
-                              #'string-lessp)
-                             " ")))
-         (view-name-re (concat "\\`"
-                               (regexp-quote default-view-name)
-                               " \\([0-9]+\\)"))
-         old-view)
-    (cond ((setq old-view
-                 (cl-find-if
-                  (lambda (x)
-                    (string-match view-name-re (car x)))
-                  ivy-views))
-           (format "%s %d"
-                   default-view-name
-                   (1+ (string-to-number
-                        (match-string 1 (car old-view))))))
-          ((assoc default-view-name ivy-views)
-           (concat default-view-name " 1"))
-          (t
-           default-view-name))))
-
-(defun ivy-push-view (&optional arg)
-  "Push the current window tree on `ivy-views'.
-
-When ARG is non-nil, replace a selected item on `ivy-views'.
-
-Currently, the split configuration (i.e. horizonal or vertical)
-and point positions are saved, but the split positions aren't.
-Use `ivy-pop-view' to delete any item from `ivy-views'."
-  (interactive "P")
-  (let* ((view (cl-labels
-                   ((ft (tr)
-                      (if (consp tr)
-                          (if (eq (car tr) t)
-                              (cons 'vert
-                                    (mapcar #'ft (cddr tr)))
-                            (cons 'horz
-                                  (mapcar #'ft (cddr tr))))
-                        (with-current-buffer (window-buffer tr)
-                          (cond (buffer-file-name
-                                 (list 'file buffer-file-name (point)))
-                                ((eq major-mode 'dired-mode)
-                                 (list 'file default-directory (point)))
-                                (t
-                                 (list 'buffer (buffer-name) (point))))))))
-                 (ft (car (window-tree)))))
-         (view-name
-          (if arg
-              (ivy-read "Update view: " ivy-views)
-            (ivy-read "Name view: " nil
-                      :initial-input (ivy-default-view-name)))))
-    (when view-name
-      (let ((x (assoc view-name ivy-views)))
-        (if x
-            (setcdr x (list view))
-          (push (list view-name view) ivy-views))))))
-
-(defun ivy-pop-view-action (view)
-  "Delete VIEW from `ivy-views'."
-  (setq ivy-views (delete view ivy-views))
-  (setq ivy--all-candidates
-        (delete (car view) ivy--all-candidates))
-  (setq ivy--old-cands nil))
-
-(defun ivy-pop-view ()
-  "Delete a view to delete from `ivy-views'."
-  (interactive)
-  (ivy-read "Pop view: " ivy-views
-            :preselect (caar ivy-views)
-            :action #'ivy-pop-view-action
-            :caller 'ivy-pop-view))
-
-(defun ivy-source-views ()
-  "Return the name of the views saved in `ivy-views'."
-  (mapcar #'car ivy-views))
-
-(ivy-set-sources
- 'ivy-switch-buffer
- '((original-source)
-   (ivy-source-views)))
-
-(defun ivy-set-view-recur (view)
-  "Set VIEW recursively."
-  (cond ((eq (car view) 'vert)
-         (let* ((wnd1 (selected-window))
-                (wnd2 (split-window-vertically))
-                (views (cdr view))
-                (v (pop views)))
-           (with-selected-window wnd1
-             (ivy-set-view-recur v))
-           (while (setq v (pop views))
-             (with-selected-window wnd2
-               (ivy-set-view-recur v))
-             (when views
-               (setq wnd2 (split-window-vertically))))))
-        ((eq (car view) 'horz)
-         (let* ((wnd1 (selected-window))
-                (wnd2 (split-window-horizontally))
-                (views (cdr view))
-                (v (pop views)))
-           (with-selected-window wnd1
-             (ivy-set-view-recur v))
-           (while (setq v (pop views))
-             (with-selected-window wnd2
-               (ivy-set-view-recur v))
-             (when views
-               (setq wnd2 (split-window-horizontally))))))
-        ((eq (car view) 'file)
-         (let* ((name (nth 1 view))
-                (virtual (assoc name ivy--virtual-buffers))
-                buffer)
-           (cond ((setq buffer (get-buffer name))
-                  (switch-to-buffer buffer nil 'force-same-window))
-                 (virtual
-                  (find-file (cdr virtual)))
-                 ((file-exists-p name)
-                  (find-file name))))
-         (when (and (> (length view) 2)
-                    (numberp (nth 2 view)))
-           (goto-char (nth 2 view))))
-        ((eq (car view) 'buffer)
-         (switch-to-buffer (nth 1 view))
-         (when (and (> (length view) 2)
-                    (numberp (nth 2 view)))
-           (goto-char (nth 2 view))))
-        ((eq (car view) 'sexp)
-         (eval (nth 1 view)))))
-
-(defun ivy--switch-buffer-action (buffer)
-  "Switch to BUFFER.
-BUFFER may be a string or nil."
-  (if (zerop (length buffer))
-      (switch-to-buffer
-       ivy-text nil 'force-same-window)
-    (let ((virtual (assoc buffer ivy--virtual-buffers))
-          (view (assoc buffer ivy-views)))
-      (cond ((and virtual
-                  (not (get-buffer buffer)))
-             (find-file (cdr virtual)))
-            (view
-             (delete-other-windows)
-             (let (
-                   ;; silence "Directory has changed on disk"
-                   (inhibit-message t))
-               (ivy-set-view-recur (cadr view))))
-            (t
-             (switch-to-buffer
-              buffer nil 'force-same-window))))))
-
-(defun ivy--switch-buffer-other-window-action (buffer)
-  "Switch to BUFFER in other window.
-BUFFER may be a string or nil."
-  (if (zerop (length buffer))
-      (switch-to-buffer-other-window ivy-text)
-    (let ((virtual (assoc buffer ivy--virtual-buffers)))
-      (if (and virtual
-               (not (get-buffer buffer)))
-          (find-file-other-window (cdr virtual))
-        (switch-to-buffer-other-window buffer)))))
-
-(defun ivy--rename-buffer-action (buffer)
-  "Rename BUFFER."
-  (let ((new-name (read-string "Rename buffer (to new name): ")))
-    (with-current-buffer buffer
-      (rename-buffer new-name))))
-
-(defun ivy--find-file-action (buffer)
-  "Find file from BUFFER's directory."
-  (let ((default-directory (buffer-local-value 'default-directory
-                                               (or (get-buffer buffer)
-                                                   (current-buffer)))))
-    (call-interactively (if (functionp 'counsel-find-file)
-                            #'counsel-find-file
-                          #'find-file))))
-
-(defun ivy--kill-buffer-action (buffer)
-  "Kill BUFFER."
-  (kill-buffer buffer)
-  (unless (buffer-live-p (ivy-state-buffer ivy-last))
-    (setf (ivy-state-buffer ivy-last) (current-buffer)))
-  (setq ivy--index 0)
-  (ivy--reset-state ivy-last))
-
-(defvar ivy-switch-buffer-map
-  (let ((map (make-sparse-keymap)))
-    (define-key map (kbd "C-c C-k") 'ivy-switch-buffer-kill)
-    map))
-
-(defun ivy-switch-buffer-kill ()
-  "Kill the current buffer in `ivy-switch-buffer'."
-  (interactive)
-  (let ((bn (ivy-state-current ivy-last)))
-    (when (get-buffer bn)
-      (kill-buffer bn))
-    (unless (buffer-live-p (ivy-state-buffer ivy-last))
-      (setf (ivy-state-buffer ivy-last)
-            (with-ivy-window (current-buffer))))
-    (setf (ivy-state-preselect ivy-last) ivy--index)
-    (setq ivy--old-re nil)
-    (setq ivy--all-candidates (delete bn ivy--all-candidates))
-    (ivy--exhibit)))
-
-(ivy-set-actions
- 'ivy-switch-buffer
- '(("f"
-    ivy--find-file-action
-    "find file")
-   ("j"
-    ivy--switch-buffer-other-window-action
-    "other window")
-   ("k"
-    ivy--kill-buffer-action
-    "kill")
-   ("r"
-    ivy--rename-buffer-action
-    "rename")))
-
-(ivy-set-actions
- t
- `(("i" ,(lambda (x) (insert (if (stringp x) x (car x)))) "insert")
-   ("w" ,(lambda (x) (kill-new (if (stringp x) x (car x)))) "copy")))
-
-(defun ivy--switch-buffer-matcher (regexp candidates)
-  "Return REGEXP matching CANDIDATES.
-Skip buffers that match `ivy-ignore-buffers'."
-  (let ((res (ivy--re-filter regexp candidates)))
-    (if (or (null ivy-use-ignore)
-            (null ivy-ignore-buffers))
-        res
-      (or (cl-remove-if
-           (lambda (buf)
-             (cl-find-if
-              (lambda (f-or-r)
-                (if (functionp f-or-r)
-                    (funcall f-or-r buf)
-                  (string-match-p f-or-r buf)))
-              ivy-ignore-buffers))
-           res)
-          (and (eq ivy-use-ignore t)
-               res)))))
-
-(ivy-set-display-transformer
- 'ivy-switch-buffer 'ivy-switch-buffer-transformer)
-(ivy-set-display-transformer
- 'internal-complete-buffer 'ivy-switch-buffer-transformer)
-
-(defun ivy-append-face (str face)
-  "Append to STR the property FACE."
-  (setq str (copy-sequence str))
-  (ivy-add-face-text-property 0 (length str) face str t)
-  str)
-
-(defun ivy-switch-buffer-transformer (str)
-  "Transform candidate STR when switching buffers."
-  (let ((b (get-buffer str)))
-    (if (and b (buffer-file-name b))
-        (cond
-          ((buffer-modified-p b)
-           (ivy-append-face str 'ivy-modified-buffer))
-          ((and (not (file-remote-p (buffer-file-name b)))
-                (not (verify-visited-file-modtime b)))
-           (ivy-append-face str 'ivy-modified-outside-buffer))
-          (t str))
-      str)))
-
-(defun ivy-switch-buffer-occur ()
-  "Occur function for `ivy-switch-buffer' using `ibuffer'."
-  (ibuffer nil (buffer-name) (list (cons 'name ivy--old-re))))
-
-;;;###autoload
-(defun ivy-switch-buffer ()
-  "Switch to another buffer."
-  (interactive)
-  (setq this-command #'ivy-switch-buffer)
-  (ivy-read "Switch to buffer: " #'internal-complete-buffer
-            :keymap ivy-switch-buffer-map
-            :preselect (buffer-name (other-buffer (current-buffer)))
-            :action #'ivy--switch-buffer-action
-            :matcher #'ivy--switch-buffer-matcher
-            :caller 'ivy-switch-buffer))
-
-;;;###autoload
-(defun ivy-switch-view ()
-  "Switch to one of the window views stored by `ivy-push-view'."
-  (interactive)
-  (let ((ivy-initial-inputs-alist
-         '((ivy-switch-buffer . "{}"))))
-    (ivy-switch-buffer)))
-
-;;;###autoload
-(defun ivy-switch-buffer-other-window ()
-  "Switch to another buffer in another window."
-  (interactive)
-  (ivy-read "Switch to buffer in other window: " #'internal-complete-buffer
-            :matcher #'ivy--switch-buffer-matcher
-            :preselect (buffer-name (other-buffer (current-buffer)))
-            :action #'ivy--switch-buffer-other-window-action
-            :keymap ivy-switch-buffer-map
-            :caller 'ivy-switch-buffer-other-window))
-
-(define-obsolete-function-alias 'ivy-recentf 'counsel-recentf "0.8.0")
-
-(defun ivy--yank-by (fn &rest args)
-  "Pull buffer text from current line into search string.
-The region to extract is determined by the respective values of
-point before and after applying FN to ARGS."
-  (let (text)
-    (with-ivy-window
-      (let ((pos (point))
-            (bol (line-beginning-position))
-            (eol (line-end-position)))
-        (unwind-protect
-             (progn (apply fn args)
-                    (setq text (buffer-substring-no-properties
-                                pos (goto-char (max bol (min (point) eol))))))
-          (unless text
-            (goto-char pos)))))
-    (when text
-      (insert (replace-regexp-in-string "  +" " " text t t)))))
-
-(defun ivy-yank-word (&optional arg)
-  "Pull next word from buffer into search string.
-If optional ARG is non-nil, pull in the next ARG
-words (previous if ARG is negative)."
-  (interactive "p")
-  (ivy--yank-by #'forward-word arg))
-
-(defun ivy-yank-symbol (&optional arg)
-  "Pull next symbol from buffer into search string.
-If optional ARG is non-nil, pull in the next ARG
-symbols (previous if ARG is negative)."
-  (interactive "p")
-  ;; Emacs < 24.4 compatibility
-  (unless (fboundp 'forward-symbol)
-    (require 'thingatpt))
-  (ivy--yank-by #'forward-symbol (or arg 1)))
-
-(defun ivy-yank-char (&optional arg)
-  "Pull next character from buffer into search string.
-If optional ARG is non-nil, pull in the next ARG
-characters (previous if ARG is negative)."
-  (interactive "p")
-  (ivy--yank-by #'forward-char arg))
-
-(defun ivy-kill-ring-save ()
-  "Store the current candidates into the kill ring.
-If the region is active, forward to `kill-ring-save' instead."
-  (interactive)
-  (if (region-active-p)
-      (call-interactively 'kill-ring-save)
-    (kill-new
-     (mapconcat
-      #'identity
-      ivy--old-cands
-      "\n"))))
-
-(defun ivy-insert-current ()
-  "Make the current candidate into current input.
-Don't finish completion."
-  (interactive)
-  (delete-minibuffer-contents)
-  (if (and ivy--directory
-           (ivy--dirname-p (ivy-state-current ivy-last)))
-      (insert (substring (ivy-state-current ivy-last) 0 -1))
-    (insert (ivy-state-current ivy-last))))
-
-(define-obsolete-variable-alias 'ivy--preferred-re-builders
-    'ivy-preferred-re-builders "0.10.0")
-
-(defcustom ivy-preferred-re-builders
-  '((ivy--regex-plus . "ivy")
-    (ivy--regex-ignore-order . "order")
-    (ivy--regex-fuzzy . "fuzzy"))
-  "Alist of preferred re-builders with display names.
-This list can be rotated with `ivy-rotate-preferred-builders'."
-  :type '(alist :key-type function :value-type string))
-
-(defun ivy-rotate-preferred-builders ()
-  "Switch to the next re builder in `ivy-preferred-re-builders'."
-  (interactive)
-  (when ivy-preferred-re-builders
-    (setq ivy--old-re nil)
-    (setq ivy--regex-function
-          (let ((cell (assq ivy--regex-function ivy-preferred-re-builders)))
-            (car (or (cadr (memq cell ivy-preferred-re-builders))
-                     (car ivy-preferred-re-builders)))))))
-
-(defun ivy-toggle-fuzzy ()
-  "Toggle the re builder between `ivy--regex-fuzzy' and `ivy--regex-plus'."
-  (interactive)
-  (setq ivy--old-re nil)
-  (if (eq ivy--regex-function 'ivy--regex-fuzzy)
-      (setq ivy--regex-function 'ivy--regex-plus)
-    (setq ivy--regex-function 'ivy--regex-fuzzy)))
-
-(defun ivy-reverse-i-search ()
-  "Enter a recursive `ivy-read' session using the current history.
-The selected history element will be inserted into the minibuffer."
-  (interactive)
-  (let ((enable-recursive-minibuffers t)
-        (history (symbol-value (ivy-state-history ivy-last)))
-        (old-last ivy-last)
-        (ivy-recursive-restore nil))
-    (ivy-read "Reverse-i-search: "
-              (delete-dups (copy-sequence history))
-              :action (lambda (x)
-                        (ivy--reset-state
-                         (setq ivy-last old-last))
-                        (delete-minibuffer-contents)
-                        (insert (substring-no-properties x))
-                        (ivy--cd-maybe)))))
-
-(defun ivy-restrict-to-matches ()
-  "Restrict candidates to current input and erase input."
-  (interactive)
-  (delete-minibuffer-contents)
-  (setq ivy--all-candidates
-        (ivy--filter ivy-text ivy--all-candidates)))
-
-;;* Occur
-(defvar-local ivy-occur-last nil
-  "Buffer-local value of `ivy-last'.
-Can't re-use `ivy-last' because using e.g. `swiper' in the same
-buffer would modify `ivy-last'.")
-
-(defvar ivy-occur-mode-map
-  (let ((map (make-sparse-keymap)))
-    (define-key map [mouse-1] 'ivy-occur-click)
-    (define-key map (kbd "RET") 'ivy-occur-press-and-switch)
-    (define-key map (kbd "j") 'ivy-occur-next-line)
-    (define-key map (kbd "k") 'ivy-occur-previous-line)
-    (define-key map (kbd "h") 'backward-char)
-    (define-key map (kbd "l") 'forward-char)
-    (define-key map (kbd "f") 'ivy-occur-press)
-    (define-key map (kbd "g") 'ivy-occur-revert-buffer)
-    (define-key map (kbd "a") 'ivy-occur-read-action)
-    (define-key map (kbd "o") 'ivy-occur-dispatch)
-    (define-key map (kbd "c") 'ivy-occur-toggle-calling)
-    (define-key map (kbd "q") 'quit-window)
-    (define-key map (kbd "R") 'read-only-mode)
-    (define-key map (kbd "C-d") 'ivy-occur-delete-candidate)
-    map)
-  "Keymap for Ivy Occur mode.")
-
-(defun ivy-occur-toggle-calling ()
-  "Toggle `ivy-calling'."
-  (interactive)
-  (if (setq ivy-calling (not ivy-calling))
-      (progn
-        (setq mode-name "Ivy-Occur [calling]")
-        (ivy-occur-press))
-    (setq mode-name "Ivy-Occur"))
-  (force-mode-line-update))
-
-(defun ivy-occur-next-line (&optional arg)
-  "Move the cursor down ARG lines.
-When `ivy-calling' isn't nil, call `ivy-occur-press'."
-  (interactive "p")
-  (forward-line arg)
-  (when ivy-calling
-    (ivy-occur-press)))
-
-(defun ivy-occur-previous-line (&optional arg)
-  "Move the cursor up ARG lines.
-When `ivy-calling' isn't nil, call `ivy-occur-press'."
-  (interactive "p")
-  (forward-line (- arg))
-  (when ivy-calling
-    (ivy-occur-press)))
-
-(define-derived-mode ivy-occur-mode fundamental-mode "Ivy-Occur"
-  "Major mode for output from \\[ivy-occur].
-
-\\{ivy-occur-mode-map}"
-  (setq-local view-read-only nil))
-
-(defvar ivy-occur-grep-mode-map
-  (let ((map (copy-keymap ivy-occur-mode-map)))
-    (define-key map (kbd "C-x C-q") 'ivy-wgrep-change-to-wgrep-mode)
-    (define-key map "w" 'ivy-wgrep-change-to-wgrep-mode)
-    map)
-  "Keymap for Ivy Occur Grep mode.")
-
-(defun ivy-occur-delete-candidate ()
-  (interactive)
-  (let ((inhibit-read-only t))
-    (delete-region (line-beginning-position)
-                   (1+ (line-end-position)))))
-
-(define-derived-mode ivy-occur-grep-mode grep-mode "Ivy-Occur"
-  "Major mode for output from \\[ivy-occur].
-
-\\{ivy-occur-grep-mode-map}"
-  (setq-local view-read-only nil)
-  (when (fboundp 'wgrep-setup)
-    (wgrep-setup)))
-
-(defvar ivy--occurs-list nil
-  "A list of custom occur generators per command.")
-
-(defun ivy-set-occur (cmd occur)
-  "Assign CMD a custom OCCUR function."
-  (setq ivy--occurs-list
-        (plist-put ivy--occurs-list cmd occur)))
-
-(ivy-set-occur 'ivy-switch-buffer 'ivy-switch-buffer-occur)
-(ivy-set-occur 'ivy-switch-buffer-other-window 'ivy-switch-buffer-occur)
-
-(defun ivy--occur-insert-lines (cands)
-  "Insert CANDS into `ivy-occur' buffer."
-  (dolist (str cands)
-    (add-text-properties
-     0 (length str)
-     `(mouse-face
-       highlight
-       help-echo "mouse-1: call ivy-action")
-     str)
-    (insert str "\n"))
-  (goto-char (point-min))
-  (forward-line 4))
-
-(defun ivy-occur ()
-  "Stop completion and put the current candidates into a new buffer.
-
-The new buffer remembers current action(s).
-
-While in the *ivy-occur* buffer, selecting a candidate with RET or
-a mouse click will call the appropriate action for that candidate.
-
-There is no limit on the number of *ivy-occur* buffers."
-  (interactive)
-  (if (not (window-minibuffer-p))
-      (user-error "No completion session is active")
-    (let* ((caller (ivy-state-caller ivy-last))
-           (occur-fn (plist-get ivy--occurs-list caller))
-           (buffer
-            (generate-new-buffer
-             (format "*ivy-occur%s \"%s\"*"
-                     (if caller
-                         (concat " " (prin1-to-string caller))
-                       "")
-                     ivy-text))))
-      (with-current-buffer buffer
-        (let ((inhibit-read-only t))
-          (erase-buffer)
-          (if occur-fn
-              (funcall occur-fn)
-            (ivy-occur-mode)
-            (insert (format "%d candidates:\n" (length ivy--old-cands)))
-            (read-only-mode)
-            (ivy--occur-insert-lines
-             (mapcar
-              (lambda (cand) (concat "    " cand))
-              ivy--old-cands))))
-        (setf (ivy-state-text ivy-last) ivy-text)
-        (setq ivy-occur-last ivy-last)
-        (setq-local ivy--directory ivy--directory))
-      (ivy-exit-with-action
-       (lambda (_) (pop-to-buffer buffer))))))
-
-(defun ivy-occur-revert-buffer ()
-  "Refresh the buffer making it up-to date with the collection.
-
-Currently only works for `swiper'.  In that specific case, the
-*ivy-occur* buffer becomes nearly useless as the orignal buffer
-is updated, since the line numbers no longer match.
-
-Calling this function is as if you called `ivy-occur' on the
-updated original buffer."
-  (interactive)
-  (let ((caller (ivy-state-caller ivy-occur-last))
-        (ivy-last ivy-occur-last))
-    (cond ((eq caller 'swiper)
-           (let ((buffer (ivy-state-buffer ivy-occur-last)))
-             (unless (buffer-live-p buffer)
-               (error "Buffer was killed"))
-             (let ((inhibit-read-only t))
-               (erase-buffer)
-               (funcall (plist-get ivy--occurs-list caller) t)
-               (ivy-occur-grep-mode))))
-          ((memq caller '(counsel-git-grep counsel-grep counsel-ag counsel-rg))
-           (let ((inhibit-read-only t))
-             (erase-buffer)
-             (funcall (plist-get ivy--occurs-list caller)))))
-    (setq ivy-occur-last ivy-last)))
-
-(declare-function wgrep-change-to-wgrep-mode "ext:wgrep")
-
-(defun ivy-wgrep-change-to-wgrep-mode ()
-  "Forward to `wgrep-change-to-wgrep-mode'."
-  (interactive)
-  (if (require 'wgrep nil 'noerror)
-      (wgrep-change-to-wgrep-mode)
-    (error "Package wgrep isn't installed")))
-
-(defun ivy-occur-read-action ()
-  "Select one of the available actions as the current one."
-  (interactive)
-  (let ((ivy-last ivy-occur-last))
-    (ivy-read-action)))
-
-(defun ivy-occur-dispatch ()
-  "Call one of the available actions on the current item."
-  (interactive)
-  (let* ((state-action (ivy-state-action ivy-occur-last))
-         (actions (if (symbolp state-action)
-                      state-action
-                    (copy-sequence state-action))))
-    (unwind-protect
-         (progn
-           (ivy-occur-read-action)
-           (ivy-occur-press))
-      (setf (ivy-state-action ivy-occur-last) actions))))
-
-(defun ivy-occur-click (event)
-  "Execute action for the current candidate.
-EVENT gives the mouse position."
-  (interactive "e")
-  (let ((window (posn-window (event-end event)))
-        (pos (posn-point (event-end event))))
-    (with-current-buffer (window-buffer window)
-      (goto-char pos)
-      (ivy-occur-press))))
-
-(declare-function swiper--cleanup "swiper")
-(declare-function swiper--add-overlays "swiper")
-(defvar ivy-occur-timer nil)
-(defvar counsel-grep-last-line)
-
-(defun ivy--occur-press-update-window ()
-  (cl-case (ivy-state-caller ivy-occur-last)
-    ((swiper counsel-git-grep counsel-grep counsel-ag counsel-rg)
-     (let ((window (ivy-state-window ivy-occur-last)))
-       (when (or (null (window-live-p window))
-                 (equal window (selected-window)))
-         (save-selected-window
-           (setf (ivy-state-window ivy-occur-last)
-                 (display-buffer (ivy-state-buffer ivy-occur-last)
-                                 'display-buffer-pop-up-window))))))
-
-    ((counsel-describe-function counsel-describe-variable)
-     (setf (ivy-state-window ivy-occur-last)
-           (selected-window))
-     (selected-window))))
-
-(defun ivy--occur-press-buffer ()
-  (let ((buffer (ivy-state-buffer ivy-last)))
-    (if (buffer-live-p buffer)
-        buffer
-      (current-buffer))))
-
-(defun ivy-occur-press ()
-  "Execute action for the current candidate."
-  (interactive)
-  (ivy--occur-press-update-window)
-  (when (save-excursion
-          (beginning-of-line)
-          (looking-at "\\(?:./\\|    \\)\\(.*\\)$"))
-    (let* ((ivy-last ivy-occur-last)
-           (ivy-text (ivy-state-text ivy-last))
-           (str (buffer-substring
-                 (match-beginning 1)
-                 (match-end 1)))
-           (coll (ivy-state-collection ivy-last))
-           (action (ivy--get-action ivy-last))
-           (ivy-exit 'done))
-      (with-ivy-window
-        (setq counsel-grep-last-line nil)
-        (with-current-buffer (ivy--occur-press-buffer)
-          (funcall action
-                   (if (and (consp coll)
-                            (consp (car coll)))
-                       (assoc str coll)
-                     str)))
-        (if (memq (ivy-state-caller ivy-last)
-                  '(swiper counsel-git-grep counsel-grep counsel-ag counsel-rg))
-            (with-current-buffer (window-buffer (selected-window))
-              (swiper--cleanup)
-              (swiper--add-overlays
-               (ivy--regex ivy-text)
-               (line-beginning-position)
-               (line-end-position)
-               (selected-window))
-              (when (timerp ivy-occur-timer)
-                (cancel-timer ivy-occur-timer))
-              (setq ivy-occur-timer
-                    (run-at-time 1.0 nil 'swiper--cleanup))))))))
-
-(defun ivy-occur-press-and-switch ()
-  "Execute action for the current candidate and switch window."
-  (interactive)
-  (ivy-occur-press)
-  (select-window (ivy--get-window ivy-occur-last)))
-
-(defconst ivy-help-file (let ((default-directory
-                               (if load-file-name
-                                   (file-name-directory load-file-name)
-                                 default-directory)))
-                          (if (file-exists-p "ivy-help.org")
-                              (expand-file-name "ivy-help.org")
-                            (if (file-exists-p "doc/ivy-help.org")
-                                (expand-file-name "doc/ivy-help.org"))))
-  "The file for `ivy-help'.")
-
-(defun ivy-help ()
-  "Help for `ivy'."
-  (interactive)
-  (let ((buf (get-buffer "*Ivy Help*")))
-    (unless buf
-      (setq buf (get-buffer-create "*Ivy Help*"))
-      (with-current-buffer buf
-        (insert-file-contents ivy-help-file)
-        (org-mode)
-        (view-mode)
-        (goto-char (point-min))))
-    (if (eq this-command 'ivy-help)
-        (switch-to-buffer buf)
-      (with-ivy-window
-        (pop-to-buffer buf)))
-    (view-mode)
-    (goto-char (point-min))))
-
-(provide 'ivy)
-
-;;; ivy.el ends here