about summary refs log tree commit diff
path: root/configs/shared/emacs/.emacs.d/elpa/emojify-20180611.1538/emojify.el
diff options
context:
space:
mode:
Diffstat (limited to 'configs/shared/emacs/.emacs.d/elpa/emojify-20180611.1538/emojify.el')
-rw-r--r--configs/shared/emacs/.emacs.d/elpa/emojify-20180611.1538/emojify.el2122
1 files changed, 0 insertions, 2122 deletions
diff --git a/configs/shared/emacs/.emacs.d/elpa/emojify-20180611.1538/emojify.el b/configs/shared/emacs/.emacs.d/elpa/emojify-20180611.1538/emojify.el
deleted file mode 100644
index 1e0ccea0e5ea..000000000000
--- a/configs/shared/emacs/.emacs.d/elpa/emojify-20180611.1538/emojify.el
+++ /dev/null
@@ -1,2122 +0,0 @@
-;;; emojify.el --- Display emojis in Emacs           -*- lexical-binding: t; -*-
-
-;; Copyright (C) 2015-2018  Iqbal Ansari
-
-;; Author: Iqbal Ansari <iqbalansari02@yahoo.com>
-;; Keywords: multimedia, convenience
-;; URL: https://github.com/iqbalansari/emacs-emojify
-;; Version: 1.0
-;; Package-Requires: ((seq "1.11") (ht "2.0") (emacs "24.3"))
-
-;; This program is free software; you can redistribute it and/or modify
-;; it under the terms of the GNU General Public License as published by
-;; the Free Software Foundation, either version 3 of the License, or
-;; (at your option) any later version.
-
-;; This program is distributed in the hope that it will be useful,
-;; but WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-;; GNU General Public License for more details.
-
-;; You should have received a copy of the GNU General Public License
-;; along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-;;; Commentary:
-
-;; This package displays emojis in Emacs similar to how Github, Slack etc do.  It
-;; can display plain ascii like ':)' as well as Github style emojis like ':smile:'
-;;
-;; It provides a minor mode `emojify-mode' to enable display of emojis in a buffer.
-;; To enable emojify mode globally use `global-emojify-mode'
-;;
-;; For detailed documentation see the projects README file at
-;; https://github.com/iqbalansari/emacs-emojify
-
-
-
-;;; Code:
-
-(require 'seq)
-(require 'ht)
-
-(require 'subr-x nil :no-error)
-(require 'cl-lib)
-(require 'json)
-(require 'regexp-opt)
-(require 'jit-lock)
-(require 'pcase)
-(require 'tar-mode)
-(require 'apropos)
-
-
-
-;; Satisfying the byte-compiler
-;; We do not "require" these functions but if `org-mode' is active we use them
-
-;; Required to determine point is in an org-list
-(declare-function org-list-get-item-begin "org-list")
-(declare-function org-at-heading-p "org")
-
-;; Required to determine point is in an org-src block
-(declare-function org-element-type "org-element")
-(declare-function org-element-at-point "org-element")
-
-;; Required for integration with company-mode
-(declare-function company-pseudo-tooltip-unhide "company")
-
-;; Shouldn't require 'jit-lock be enough :/
-(defvar jit-lock-start)
-(defvar jit-lock-end)
-
-;; Used while inserting emojis using helm
-(defvar helm-buffer)
-(defvar helm-after-initialize-hook)
-
-
-
-;; Compatibility functions
-
-(defun emojify-user-error (format &rest args)
-  "Signal a pilot error, making a message by passing FORMAT and ARGS to ‘format-message’."
-  (if (fboundp 'user-error)
-      (apply #'user-error format args)
-    (apply #'error format args)))
-
-(defun emojify-face-height (face)
-  "Get font height for the FACE."
-  (let ((face-font (face-font face)))
-    (cond
-     ((and (display-multi-font-p)
-           ;; Avoid calling font-info if the frame's default font was
-           ;; not changed since the frame was created.  That's because
-           ;; font-info is expensive for some fonts, see bug #14838.
-           (not (string= (frame-parameter nil 'font) face-font)))
-      (aref (font-info face-font) 3))
-     (t (frame-char-height)))))
-
-(defun emojify-default-font-height ()
-  "Return the height in pixels of the current buffer's default face font.
-
-`default-font-height' seems to be available only on Emacs versions after 24.3.
-This provides a compatibility version for previous versions."
-  (if (fboundp 'default-font-height)
-      (default-font-height)
-    (emojify-face-height 'default)))
-
-(defun emojify-overlays-at (pos &optional sorted)
-  "Return a list of the overlays that contain the character at POS.
-If SORTED is non-nil, then sort them by decreasing priority.
-
-The SORTED argument was introduced in Emacs 24.4, along with the incompatible
-change that overlay priorities can be any Lisp object (earlier they were
-restricted to integer and nil).  This version uses the SORTED argument of
-`overlays-at' on Emacs version 24.4 onwards and manually sorts the overlays by
-priority on lower versions."
-  (if (version< emacs-version "24.4")
-      (let ((overlays-at-pos (overlays-at pos)))
-        (if sorted
-            (seq-sort (lambda (overlay1 overlay2)
-                        (if (and (overlay-get overlay2 'priority)
-                                 (overlay-get overlay1 'priority))
-                            ;; If both overlays have priorities compare them
-                            (< (overlay-get overlay1 'priority)
-                               (overlay-get overlay2 'priority))
-                          ;; Otherwise overlay with nil priority is sorted below
-                          ;; the one with integer value otherwise preserve order
-                          (not (overlay-get overlay1 'priority))))
-                      overlays-at-pos)
-          overlays-at-pos))
-    (overlays-at pos sorted)))
-
-(defun emojify--string-join (strings &optional separator)
-  "Join all STRINGS using SEPARATOR.
-
-This function is available on Emacs v24.4 and higher, it has been
-backported here for compatibility with older Emacsen."
-  (if (fboundp 'string-join)
-      (apply #'string-join (list strings separator))
-    (mapconcat 'identity strings separator)))
-
-
-
-;; Debugging helpers
-
-(define-minor-mode emojify-debug-mode
-  "Enable debugging for emojify-mode.
-
-By default emojify silences any errors during emoji redisplay.  This is done
-since emojis are redisplayed using jit-lock (the same mechanism used for
-font-lock) as such any bugs in the code can cause other important things to
-fail. This also turns on jit-debug-mode so that (e)debugging emojify's redisplay
-functions work."
-  :init-value nil
-  (if emojify-debug-mode
-      (when (fboundp 'jit-lock-debug-mode)
-        (jit-lock-debug-mode +1))
-    (when (fboundp 'jit-lock-debug-mode)
-      (jit-lock-debug-mode -1))))
-
-(defmacro emojify-execute-ignoring-errors-unless-debug (&rest forms)
-  "Execute FORMS ignoring errors unless variable `emojify-debug-mode' is non-nil."
-  (declare (debug t) (indent 0))
-  `(if emojify-debug-mode
-       (progn
-         ,@forms)
-     (ignore-errors
-       ,@forms)))
-
-
-
-;; Utility functions
-
-;; These should be bound dynamically by functions calling
-;; `emojify--inside-rectangle-selection-p' and
-;; `emojify--inside-non-rectangle-selection-p' to region-beginning and
-;; region-end respectively. This is needed mark the original region which is
-;; impossible to get after point moves during processing.
-(defvar emojify-region-beg nil)
-(defvar emojify-region-end nil)
-
-;; This should be bound dynamically to the location of point before emojify's
-;; display loop, this since getting the point after point moves during
-;; processing is impossible
-(defvar emojify-current-point nil)
-
-(defmacro emojify-with-saved-buffer-state (&rest forms)
-  "Execute FORMS saving current buffer state.
-
-This saves point and mark, `match-data' and buffer modification state it also
-inhibits buffer change, point motion hooks."
-  (declare (debug t) (indent 0))
-  `(let ((inhibit-point-motion-hooks t)
-         (emojify-current-point (point))
-         (emojify-region-beg (when (region-active-p) (region-beginning)))
-         (emojify-region-end (when (region-active-p) (region-end))))
-     (with-silent-modifications
-       (save-match-data
-         (save-excursion
-           (save-restriction
-             (widen)
-             ,@forms))))))
-
-(defmacro emojify-do-for-emojis-in-region (beg end &rest forms)
-  "For all emojis between BEG and END, execute the given FORMS.
-
-During the execution `emoji-start' and `emoji-end' are bound to the start
-and end of the emoji for which the form is being executed."
-  (declare (debug t) (indent 2))
-  `(let ((--emojify-loop-current-pos ,beg)
-         (--emojify-loop-end ,end)
-         emoji-start)
-     (while (and (> --emojify-loop-end --emojify-loop-current-pos)
-                 (setq emoji-start (text-property-any --emojify-loop-current-pos --emojify-loop-end 'emojified t)))
-       (let ((emoji-end (+ emoji-start
-                           (length (get-text-property emoji-start 'emojify-text)))))
-         ,@forms
-         (setq --emojify-loop-current-pos emoji-end)))))
-
-(defun emojify-message (format-string &rest args)
-  "Log debugging messages to buffer named 'emojify-log'.
-
-This is a substitute to `message' since using it during redisplay causes errors.
-FORMAT-STRING and ARGS are same as the arguments to `message'."
-  (when emojify-debug-mode
-    (emojify-with-saved-buffer-state
-      (with-current-buffer (get-buffer-create "emojify-log")
-        (goto-char (point-max))
-        (insert (apply #'format format-string args))
-        (insert "\n")))))
-
-(defun emojify--get-relevant-region ()
-  "Try getting region in buffer that completely covers the current window.
-
-This is used instead of directly using `window-start' and `window-end', since
-they return the values corresponding buffer in currently selected window, which
-is incorrect if the buffer where there are called is not actually the buffer
-visible in the selected window."
-  (let* ((window-size (- (window-end) (window-start)))
-         (start (max (- (point) window-size) (point-min)))
-         (end (min (+ (point) window-size) (point-max))))
-    (cons start end)))
-
-(defun emojify-quit-buffer ()
-  "Hide the current buffer.
-There are windows other than the one the current buffer is displayed in quit the
-current window too."
-  (interactive)
-  (if (= (length (window-list)) 1)
-      (bury-buffer)
-    (quit-window)))
-
-(defvar emojify-common-mode-map
-  (let ((map (make-sparse-keymap)))
-    (define-key map "q" #'emojify-quit-buffer)
-    (define-key map "n" #'next-line)
-    (define-key map "p" #'previous-line)
-    (define-key map "r" #'isearch-backward)
-    (define-key map "s" #'isearch-forward)
-    (define-key map ">" #'end-of-buffer)
-    (define-key map "<" #'beginning-of-buffer)
-
-    (dolist (key '("?" "h" "H"))
-      (define-key map key #'describe-mode))
-
-    (dolist (number (number-sequence 0 9))
-      (define-key map (number-to-string number) #'digit-argument))
-
-    map)
-  "Common keybindings available in all special emojify buffers.")
-
-
-
-;; Customizations for control how emojis are displayed
-
-(defgroup emojify nil
-  "Customization options for emojify"
-  :group 'display
-  :prefix "emojify-")
-
-(defcustom emojify-emoji-json
-  (expand-file-name "data/emoji.json"
-                    (cond (load-file-name (file-name-directory load-file-name))
-                          ((locate-library "emojify") (file-name-directory (locate-library "emojify")))
-                          (t default-directory)))
-  "The path to JSON file containing the configuration for displaying emojis."
-  :type 'file
-  :group 'emojify)
-
-(defvar emojify-emoji-set-json
-  (let ((json-array-type 'list)
-        (json-object-type 'hash-table))
-    (json-read-file (expand-file-name "data/emoji-sets.json"
-                                      (cond (load-file-name (file-name-directory load-file-name))
-                                            ((locate-library "emojify") (file-name-directory (locate-library "emojify")))
-                                            (t default-directory))))))
-
-(defcustom emojify-emoji-set "emojione-v2.2.6-22"
-  "The emoji set used to display emojis."
-  :type (append '(radio :tag "Emoji set")
-                (mapcar (lambda (set) (list 'const set))
-                        (ht-keys emojify-emoji-set-json)))
-  :group 'emojify)
-
-(defcustom emojify-emojis-dir
-  (locate-user-emacs-file "emojis")
-  "Path to the directory containing the emoji images."
-  :type 'directory
-  :group 'emojify)
-
-(defcustom emojify-display-style
-  'image
-  "How the emoji's be displayed.
-
-Possible values are
-`image'   - Display emojis using images, this requires images are supported by
-            user's Emacs installation
-`unicode' - Display emojis using unicode characters, this works well on
-            platforms with good emoji fonts.  In this case the emoji text
-            ':wink:' will be substituted with 😉.
-`ascii'   - Display emojis as ascii characters, this is simplest and does not
-            require any external dependencies.  In this cases emoji text like
-            ':wink:' are substituted with ascii equivalents like ';)'"
-  :type '(radio :tag "Emoji display style"
-                (const :tag "Display emojis as images" image)
-                (const :tag "Display emojis as unicode characters" unicode)
-                (const :tag "Display emojis as ascii string" ascii))
-  :group 'emojify)
-
-
-
-;; Customizations to control the enabling of emojify-mode
-
-(defcustom emojify-inhibit-major-modes
-  '(dired-mode
-    doc-view-mode
-    debugger-mode
-    pdf-view-mode
-    image-mode
-    help-mode
-    ibuffer-mode
-    magit-popup-mode
-    magit-diff-mode
-    ert-results-mode
-    compilation-mode
-    proced-mode
-    mu4e-headers-mode)
-  "Major modes where emojify mode should not be enabled."
-  :type '(repeat symbol)
-  :group 'emojify)
-
-(defcustom emojify-inhibit-in-buffer-functions
-  '(emojify-minibuffer-p emojify-helm-buffer-p)
-  "Functions used inhibit emojify-mode in a buffer.
-
-These functions are called with one argument, the buffer where command
-‘emojify-mode’ is about to be enabled, emojify is not enabled if any of the
-functions return a non-nil value."
-  :type 'hook
-  :group 'emojify)
-
-(defvar emojify-inhibit-emojify-in-current-buffer-p nil
-  "Should emojify be inhibited in current buffer.
-
-This is a buffer local variable that can be set to inhibit enabling of
-emojify in a buffer.")
-(make-variable-buffer-local 'emojify-inhibit-emojify-in-current-buffer-p)
-
-(defvar emojify-minibuffer-reading-emojis-p nil
-  "Are we currently reading emojis using minibuffer?")
-
-(defun emojify-ephemeral-buffer-p (buffer)
-  "Determine if BUFFER is an ephemeral/temporary buffer."
-  (and (not (minibufferp))
-       (string-match-p "^ " (buffer-name buffer))))
-
-(defun emojify-inhibit-major-mode-p (buffer)
-  "Determine if user has disabled the `major-mode' enabled for the BUFFER.
-
-Returns non-nil if the buffer's major mode is part of `emojify-inhibit-major-modes'"
-  (with-current-buffer buffer
-    (apply #'derived-mode-p emojify-inhibit-major-modes)))
-
-(defun emojify-helm-buffer-p (buffer)
-  "Determine if the current BUFFER is a helm buffer."
-  (unless emojify-minibuffer-reading-emojis-p
-    (string-match-p "\\*helm" (buffer-name buffer))))
-
-(defun emojify-minibuffer-p (buffer)
-  "Determine if the current BUFFER is a minibuffer."
-  (unless emojify-minibuffer-reading-emojis-p
-    (minibufferp buffer)))
-
-(defun emojify-buffer-p (buffer)
-  "Determine if `emojify-mode' should be enabled for given BUFFER.
-
-`emojify-mode' mode is not enabled in temporary buffers.  Additionally user
-can customize `emojify-inhibit-major-modes' and
-`emojify-inhibit-in-buffer-functions' to disabled emojify in additional buffers."
-  (not (or emojify-inhibit-emojify-in-current-buffer-p
-           (emojify-ephemeral-buffer-p (current-buffer))
-           (emojify-inhibit-major-mode-p (current-buffer))
-           (buffer-base-buffer buffer)
-           (run-hook-with-args-until-success 'emojify-inhibit-in-buffer-functions buffer))))
-
-
-
-;; Customizations to control display of emojis
-
-(defvar emojify-emoji-style-change-hook nil
-  "Hooks run when emoji style changes.")
-
-;;;###autoload
-(defun emojify-set-emoji-styles (styles)
-  "Set the type of emojis that should be displayed.
-
-STYLES is the styles emoji styles that should be used, see `emojify-emoji-styles'"
-  (when (not (listp styles))
-    (setq styles (list styles))
-    (warn "`emojify-emoji-style' has been deprecated use `emojify-emoji-styles' instead!"))
-
-  (setq-default emojify-emoji-styles styles)
-
-  (run-hooks 'emojify-emoji-style-change-hook))
-
-(defcustom emojify-emoji-styles
-  '(ascii unicode github)
-  "The type of emojis that should be displayed.
-
-These can have one of the following values
-
-`ascii'           - Display only ascii emojis for example ';)'
-`unicode'         - Display only unicode emojis for example '😉'
-`github'          - Display only github style emojis for example ':wink:'"
-  :type '(set
-          (const :tag "Display only ascii emojis" ascii)
-          (const :tag "Display only github emojis" github)
-          (const :tag "Display only unicode codepoints" unicode))
-  :set (lambda (_ value) (emojify-set-emoji-styles value))
-  :group 'emojify)
-
-(defcustom emojify-program-contexts
-  '(comments string code)
-  "Contexts where emojis can be displayed in programming modes.
-
-Possible values are
-`comments' - Display emojis in comments
-`string'   - Display emojis in strings
-`code'     - Display emojis in code (this is applicable only for unicode emojis)"
-  :type '(set :tag "Contexts where emojis should be displayed in programming modes"
-              (const :tag "Display emojis in comments" comments)
-              (const :tag "Display emojis in string" string)
-              (const :tag "Display emojis in code" code))
-  :group 'emojify)
-
-(defcustom emojify-inhibit-functions
-  '(emojify-in-org-tags-p emojify-in-org-list-p)
-  "Functions used to determine given emoji should displayed at current point.
-
-These functions are called with 3 arguments, the text to be emojified, the start
-of emoji text and the end of emoji text.  These functions are called with the
-buffer where emojis are going to be displayed selected."
-  :type 'hook
-  :group 'emojify)
-
-(defcustom emojify-composed-text-p t
-  "Should composed text be emojified."
-  :type 'boolean
-  :group 'emojify)
-
-(defcustom emojify-company-tooltips-p t
-  "Should company mode tooltips be emojified."
-  :type 'boolean
-  :group 'emojify)
-
-(defun emojify-in-org-tags-p (match beg _end)
-  "Determine whether the point is on `org-mode' tag.
-
-MATCH, BEG and _END are the text currently matched emoji and the start position
-and end position of emoji text respectively.
-
-Easiest would have to inspect face at point but unfortunately, there is no
-way to guarantee that we run after font-lock"
-  (and (memq major-mode '(org-mode org-agenda-mode))
-       (string-match-p ":[^:]+[:]?" match)
-       (org-at-heading-p)
-       (save-excursion
-         (save-match-data
-           (goto-char beg)
-           (looking-at ":[^:]+:[\s-]*$")))))
-
-(defun emojify-in-org-list-p (text beg &rest ignored)
-  "Determine whether the point is in `org-mode' list.
-
-TEXT is the text which is supposed to rendered a an emoji.  BEG is the beginning
-of the emoji text in the buffer.  The arguments IGNORED are ignored."
-  (and (eq major-mode 'org-mode)
-       (equal text "8)")
-       (equal (org-list-get-item-begin) beg)))
-
-(defun emojify-valid-program-context-p (emoji beg end)
-  "Determine if EMOJI should be displayed for text between BEG and END.
-
-This returns non-nil if the region is valid according to `emojify-program-contexts'"
-  (when emojify-program-contexts
-    (let* ((syntax-beg (syntax-ppss beg))
-           (syntax-end (syntax-ppss end))
-           (context (cond ((and (nth 3 syntax-beg)
-                                (nth 3 syntax-end))
-                           'string)
-                          ((and (nth 4 syntax-beg)
-                                (nth 4 syntax-end))
-                           'comments)
-                          (t 'code))))
-      (and (memql context emojify-program-contexts)
-           (if (equal context 'code)
-               (and (string= (ht-get emoji "style") "unicode")
-                    (memql 'unicode emojify-emoji-styles))
-             t)))))
-
-(defun emojify-inside-org-src-p (point)
-  "Return non-nil if POINT is inside `org-mode' src block.
-
-This is used to inhibit display of emoji's in `org-mode' src blocks
-since our mechanisms do not work in it."
-  (when (eq major-mode 'org-mode)
-    (save-excursion
-      (goto-char point)
-      (eq (org-element-type (org-element-at-point)) 'src-block))))
-
-(defun emojify-looking-at-end-of-list-maybe (point)
-  "Determine if POINT is end of a list.
-
-This is not accurate since it restricts the region to scan to
-the visible area."
-  (let* ((area (emojify--get-relevant-region))
-         (beg (car area))
-         (end (cdr area)))
-    (save-restriction
-      (narrow-to-region beg end)
-      (let ((list-start (ignore-errors (scan-sexps point -1))))
-        (when (and list-start
-                   ;; Ignore the starting brace if it is an emoji
-                   (not (get-text-property list-start 'emojified)))
-          ;; If we got a list start make sure both start and end
-          ;; belong to same string/comment
-          (let ((syntax-beg (syntax-ppss list-start))
-                (syntax-end (syntax-ppss point)))
-            (and list-start
-                 (eq (nth 8 syntax-beg)
-                     (nth 8 syntax-end)))))))))
-
-(defun emojify-valid-ascii-emoji-context-p (beg end)
-  "Determine if the okay to display ascii emoji between BEG and END."
-  ;; The text is at the start of the buffer
-  (and (or (not (char-before beg))
-           ;; 32 space since ?  (? followed by a space) is not readable
-           ;; 34 is "  since?" confuses font-lock
-           ;; 41 is )  since?) (extra paren) confuses most packages
-           (memq (char-syntax (char-before beg))
-                 ;; space
-                 '(32
-                   ;; start/end of string
-                   34
-                   ;; whitespace syntax
-                   ?-
-                   ;; comment start
-                   ?<
-                   ;; comment end, this handles text at start of line immediately
-                   ;; after comment line in a multiline comment
-                   ?>)))
-       ;; The text is at the end of the buffer
-       (or (not (char-after end))
-           (memq (char-syntax (char-after end))
-                 ;; space
-                 '(32
-                   ;; start/end of string
-                   34
-                   ;; whitespace syntax
-                   ?-
-                   ;; punctuation
-                   ?.
-                   ;; closing braces
-                   41
-                   ;; comment end
-                   ?>)))))
-
-
-
-;; Obsolete vars
-
-(define-obsolete-variable-alias 'emojify-emoji-style 'emojify-emoji-styles "0.2")
-(define-obsolete-function-alias 'emojify-set-emoji-style 'emojify-set-emoji-styles "0.2")
-
-
-
-;; Customizations to control the behaviour when point enters emojified text
-
-(defcustom emojify-point-entered-behaviour 'echo
-  "The behaviour when point enters, an emojified text.
-
-It can be one of the following
-`echo'    - Echo the underlying text in the minibuffer
-`uncover' - Display the underlying text while point is on it
-function  - It is called with 2 arguments (the buffer where emoji appears is
-            current during execution)
-            1) starting position of emoji text
-            2) ending position of emoji text
-
-Does nothing if the value is anything else."
-  ;; TODO: Mention custom function
-  :type '(radio :tag "Behaviour when point enters an emoji"
-                (const :tag "Echo the underlying emoji text in the minibuffer" echo)
-                (const :tag "Uncover (undisplay) the underlying emoji text" uncover))
-  :group 'emojify)
-
-(defcustom emojify-reveal-on-isearch t
-  "Should underlying emoji be displayed when point enters emoji while in isearch mode.")
-
-(defcustom emojify-show-help t
-  "If non-nil the underlying text is displayed in a popup when mouse moves over it."
-  :type 'boolean
-  :group 'emojify)
-
-(defun emojify-on-emoji-enter (beginning end)
-  "Executed when point enters emojified text between BEGINNING and END."
-  (cond ((and (eq emojify-point-entered-behaviour 'echo)
-              ;; Do not echo in isearch-mode
-              (not isearch-mode)
-              (not (active-minibuffer-window))
-              (not (current-message)))
-         (message (substring-no-properties (get-text-property beginning 'emojify-text))))
-        ((eq emojify-point-entered-behaviour 'uncover)
-         (put-text-property beginning end 'display nil))
-        ((functionp 'emojify-point-entered-behaviour)
-         (funcall emojify-point-entered-behaviour beginning end)))
-
-  (when (and isearch-mode emojify-reveal-on-isearch)
-    (put-text-property beginning end 'display nil)))
-
-(defun emojify-on-emoji-exit (beginning end)
-  "Executed when point exits emojified text between BEGINNING and END."
-  (put-text-property beginning
-                     end
-                     'display
-                     (get-text-property beginning 'emojify-display)))
-
-(defvar-local emojify--last-emoji-pos nil)
-
-(defun emojify-detect-emoji-entry/exit ()
-  "Detect emoji entry and exit and run appropriate handlers.
-
-This is inspired by `prettify-symbol-mode's logic for
-`prettify-symbols-unprettify-at-point'."
-  (while-no-input
-    (emojify-with-saved-buffer-state
-      (when emojify--last-emoji-pos
-        (emojify-on-emoji-exit (car emojify--last-emoji-pos) (cdr emojify--last-emoji-pos)))
-
-      (when (get-text-property (point) 'emojified)
-        (let* ((text-props (text-properties-at (point)))
-               (buffer (plist-get text-props 'emojify-buffer))
-               (match-beginning (plist-get text-props 'emojify-beginning))
-               (match-end (plist-get text-props 'emojify-end)))
-          (when (eq buffer (current-buffer))
-            (emojify-on-emoji-enter match-beginning match-end)
-            (setq emojify--last-emoji-pos (cons match-beginning match-end))))))))
-
-(defun emojify-help-function (_window _string pos)
-  "Function to get help string to be echoed when point/mouse into the point.
-
-To understand WINDOW, STRING and POS see the function documentation for
-`help-echo' text-property."
-  (when (and emojify-show-help
-             (not isearch-mode)
-             (not (active-minibuffer-window))
-             (not (current-message)))
-    (plist-get (text-properties-at pos) 'emojify-text)))
-
-
-
-;; Core functions and macros
-
-;; Variables related to user emojis
-
-(defcustom emojify-user-emojis nil
-  "User specified custom emojis.
-
-This is an alist where first element of cons is the text to be displayed as
-emoji, while the second element of the cons is an alist containing data about
-the emoji.
-
-The inner alist should have atleast (not all keys are strings)
-
-`name'  - The name of the emoji
-`style' - This should be one of \"github\", \"ascii\" or \"github\"
-          (see `emojify-emoji-styles')
-
-The alist should contain one of (see `emojify-display-style')
-`unicode' - The replacement for the provided emoji for \"unicode\" display style
-`image'   - The replacement for the provided emoji for \"image\" display style.
-            This should be the absolute path to the image
-`ascii'   - The replacement for the provided emoji for \"ascii\" display style
-
-Example -
-The following assumes that custom images are at ~/.emacs.d/emojis/trollface.png and
-~/.emacs.d/emojis/neckbeard.png
-
-'((\":troll:\"     . ((\"name\" . \"Troll\")
-                    (\"image\" . \"~/.emacs.d/emojis/trollface.png\")
-                    (\"style\" . \"github\")))
-  (\":neckbeard:\" . ((\"name\" . \"Neckbeard\")
-                    (\"image\" . \"~/.emacs.d/emojis/neckbeard.png\")
-                    (\"style\" . \"github\"))))")
-
-(defvar emojify--user-emojis nil
-  "User specified custom emojis.")
-
-(defvar emojify--user-emojis-regexp nil
-  "Regexp to match user specified custom emojis.")
-
-;; Variables related to default emojis
-(defvar emojify-emojis nil
-  "Data about the emojis, this contains only the emojis that come with emojify.")
-
-(defvar emojify-regexps nil
-  "List of regexps to match text to be emojified.")
-
-(defvar emojify--completing-candidates-cache nil
-  "Cached values for completing read candidates calculated for `emojify-completing-read'.")
-
-;; Cache for emoji completing read candidates
-(defun emojify--get-completing-read-candidates ()
-  "Get the candidates to be used for `emojify-completing-read'.
-
-The candidates are calculated according to currently active
-`emojify-emoji-styles' and cached"
-  (let ((styles (mapcar #'symbol-name emojify-emoji-styles)))
-    (unless (and emojify--completing-candidates-cache
-                 (equal styles (car emojify--completing-candidates-cache)))
-      (setq emojify--completing-candidates-cache
-            (cons styles
-                  (let ((emojis (ht-create #'equal)))
-                    (emojify-emojis-each (lambda (key value)
-                                           (when (seq-position styles (ht-get value "style"))
-                                             (ht-set! emojis
-                                                      (format "%s - %s (%s)"
-                                                              key
-                                                              (ht-get value "name")
-                                                              (ht-get value "style"))
-                                                      value))))
-                    emojis))))
-    (cdr emojify--completing-candidates-cache)))
-
-(defun emojify-create-emojify-emojis (&optional force)
-  "Create `emojify-emojis' if needed.
-
-The function avoids reading emoji data if it has already been read unless FORCE
-in which case emoji data is re-read."
-  (when (or force (not emojify-emojis))
-    (emojify-set-emoji-data)))
-
-(defun emojify-get-emoji (emoji)
-  "Get data for given EMOJI.
-
-This first looks for the emoji in `emojify--user-emojis',
-and then in `emojify-emojis'."
-  (or (when emojify--user-emojis
-        (ht-get emojify--user-emojis emoji))
-      (ht-get emojify-emojis emoji)))
-
-(defun emojify-emojis-each (function)
-  "Execute FUNCTION for each emoji.
-
-This first runs function for `emojify--user-emojis',
-and then `emojify-emojis'."
-  (when emojify--user-emojis
-    (ht-each function emojify--user-emojis))
-  (ht-each function emojify-emojis))
-
-(defun emojify--verify-user-emojis (emojis)
-  "Verify the EMOJIS in correct user format."
-  (seq-every-p (lambda (emoji)
-                 (and (assoc "name" (cdr emoji))
-                      ;; Make sure style is present is only one of
-                      ;; "unicode", "ascii" and "github".
-                      (assoc "style" (cdr emoji))
-                      (seq-position '("unicode" "ascii" "github")
-                                    (cdr (assoc "style" (cdr emoji))))
-                      (or (assoc "unicode" (cdr emoji))
-                          (assoc "image" (cdr emoji))
-                          (assoc "ascii" (cdr emoji)))))
-               emojis))
-
-(defun emojify-set-emoji-data ()
-  "Read the emoji data for STYLES and set the regexp required to search them."
-  (setq-default emojify-emojis (let ((json-array-type 'list)
-                                     (json-object-type 'hash-table))
-                                 (json-read-file emojify-emoji-json)))
-
-  (let (unicode-emojis ascii-emojis)
-    (ht-each (lambda (emoji data)
-               (when (string= (ht-get data "style") "unicode")
-                 (push emoji unicode-emojis))
-
-               (when (string= (ht-get data "style") "ascii")
-                 (push emoji ascii-emojis)))
-             emojify-emojis)
-
-    ;; Construct emojify-regexps such that github style are searched first
-    ;; followed by unicode and then ascii emojis.
-    (setq emojify-regexps (list ":[[:alnum:]+_-]+:"
-                                (regexp-opt unicode-emojis)
-                                (regexp-opt ascii-emojis))))
-
-  (when emojify-user-emojis
-    (if (emojify--verify-user-emojis emojify-user-emojis)
-        ;; Create entries for user emojis
-        (let ((emoji-pairs (mapcar (lambda (user-emoji)
-                                     (cons (car user-emoji)
-                                           (ht-from-alist (cdr user-emoji))))
-                                   emojify-user-emojis)))
-          (setq emojify--user-emojis (ht-from-alist emoji-pairs))
-          (setq emojify--user-emojis-regexp (regexp-opt (mapcar #'car emoji-pairs))))
-      (message "[emojify] User emojis are not in correct format ignoring them.")))
-
-  (emojify-emojis-each (lambda (emoji data)
-                         ;; Add the emoji text to data, this makes the values
-                         ;; of the `emojify-emojis' standalone containing all
-                         ;; data about the emoji
-                         (ht-set! data "emoji" emoji)
-                         (ht-set! data "custom" (and emojify--user-emojis
-                                                     (ht-get emojify--user-emojis emoji)))))
-
-  ;; Clear completion candidates cache
-  (setq emojify--completing-candidates-cache nil))
-
-(defvar emojify-emoji-keymap
-  (let ((map (make-sparse-keymap)))
-    (define-key map [remap delete-char] #'emojify-delete-emoji-forward)
-    (define-key map [remap delete-forward-char] #'emojify-delete-emoji-forward)
-    (define-key map [remap backward-delete-char] #'emojify-delete-emoji-backward)
-    (define-key map [remap org-delete-backward-char] #'emojify-delete-emoji-backward)
-    (define-key map [remap delete-backward-char] #'emojify-delete-emoji-backward)
-    (define-key map [remap backward-delete-char-untabify] #'emojify-delete-emoji-backward)
-    map))
-
-(defun emojify-image-dir ()
-  "Get the path to directory containing images for currently selected emoji set."
-  (expand-file-name emojify-emoji-set
-                    emojify-emojis-dir))
-
-(defun emojify--get-point-col-and-line (point)
-  "Return a cons of containing the column number and line at POINT."
-  (save-excursion
-    (goto-char point)
-    (cons (current-column) (line-number-at-pos))))
-
-(defun emojify--get-composed-text (point)
-  "Get the text used as composition property at POINT.
-
-This does not check if there is composition property at point the callers should
-make sure the point has a composition property otherwise this function will
-fail."
-  (emojify--string-join (mapcar #'char-to-string
-                                (decode-composition-components (nth 2
-                                                                    (find-composition point
-                                                                                      nil
-                                                                                      nil
-                                                                                      t))))))
-
-(defun emojify--inside-rectangle-selection-p (beg end)
-  "Check if region marked by BEG and END is inside a rectangular selection.
-
-In addition to explicit the parameters BEG and END, calling functions should
-also dynamically bind `emojify-region-beg' and `emojify-region-end' to beginning
-and end of region respectively."
-  (when (and emojify-region-beg
-             (bound-and-true-p rectangle-mark-mode))
-    (let ((rect-beg (emojify--get-point-col-and-line emojify-region-beg))
-          (rect-end (emojify--get-point-col-and-line emojify-region-end))
-          (emoji-start-pos (emojify--get-point-col-and-line beg))
-          (emoji-end-pos (emojify--get-point-col-and-line end)))
-      (or (and (<= (car rect-beg) (car emoji-start-pos))
-               (<= (car emoji-start-pos) (car rect-end))
-               (<= (cdr rect-beg) (cdr emoji-start-pos))
-               (<= (cdr emoji-start-pos) (cdr rect-end)))
-          (and (<= (car rect-beg) (car emoji-end-pos))
-               (<= (car emoji-end-pos) (car rect-end))
-               (<= (cdr rect-beg) (cdr emoji-end-pos))
-               (<= (cdr emoji-end-pos) (cdr rect-end)))))))
-
-(defun emojify--inside-non-rectangle-selection-p (beg end)
-  "Check if region marked by BEG and END is inside a non-regular selection.
-
-In addition to the explicit parameters BEG and END, calling functions should
-also dynamically bind `emojify-region-beg' and `emojify-region-end' to beginning
-and end of region respectively."
-  (when (and emojify-region-beg
-             (region-active-p)
-             (not (bound-and-true-p rectangle-mark-mode)))
-    (or (and (<  emojify-region-beg beg)
-             (<= beg emojify-region-end))
-        (and (<  emojify-region-beg end)
-             (<= end emojify-region-end)))))
-
-(defun emojify--region-background-maybe (beg end)
-  "If the BEG and END falls inside an active region return the region face.
-
-This returns nil if the emojis between BEG and END do not fall in region."
-  ;; `redisplay-highlight-region-function' was not defined in Emacs 24.3
-  (when (and (or (not (boundp 'redisplay-highlight-region-function))
-                 (equal (default-value 'redisplay-highlight-region-function) redisplay-highlight-region-function))
-             (or (emojify--inside-non-rectangle-selection-p beg end)
-                 (emojify--inside-rectangle-selection-p beg end)))
-    (face-background 'region)))
-
-(defun emojify--get-image-background (beg end)
-  "Get the color to be used as background for emoji between BEG and END."
-  ;; We do a separate check for region since `background-color-at-point'
-  ;; does not always detect background color inside regions properly
-  (or (emojify--region-background-maybe beg end)
-      (save-excursion
-        (goto-char beg)
-        (background-color-at-point))))
-
-(defvar emojify--imagemagick-support-cache (ht-create))
-
-(defun emojify--imagemagick-supports-p (format)
-  "Check if imagemagick support given FORMAT.
-
-This function caches the result of the check since the naive check
-
-    (memq format (imagemagick-types))
-
-can be expensive if imagemagick-types returns a large list, this is
-especially problematic since this check is potentially called during
-very redisplay. See https://github.com/iqbalansari/emacs-emojify/issues/41"
-  (when (fboundp 'imagemagick-types)
-    (when (equal (ht-get emojify--imagemagick-support-cache format 'unset) 'unset)
-      (ht-set emojify--imagemagick-support-cache format (memq format (imagemagick-types))))
-    (ht-get emojify--imagemagick-support-cache format)))
-
-(defun emojify--get-image-display (data buffer beg end &optional target)
-  "Get the display text property to display the emoji as an image.
-
-DATA holds the emoji data, _BUFFER is the target buffer where the emoji is to be
-displayed, BEG and END delimit the region where emoji will be displayed.  For
-explanation of TARGET see the documentation of `emojify--get-text-display-props'.
-
-TODO: Perhaps TARGET should be generalized to work with overlays, buffers and
-other different display constructs, for now this works."
-  (when (ht-get data "image")
-    (let* ((image-file (expand-file-name (ht-get data "image")
-                                         (emojify-image-dir)))
-           (image-type (intern (upcase (file-name-extension image-file)))))
-      (when (file-exists-p image-file)
-        (create-image image-file
-                      ;; use imagemagick if available and supports PNG images
-                      ;; (allows resizing images)
-                      (when (emojify--imagemagick-supports-p image-type)
-			'imagemagick)
-                      nil
-                      :ascent 'center
-                      :heuristic-mask t
-                      :background (cond ((equal target 'mode-line)
-                                         (face-background 'mode-line nil 'default))
-                                        (t (emojify--get-image-background beg end)))
-                      ;; no-op if imagemagick is  not available
-                      :height (cond ((bufferp target)
-                                     (with-current-buffer target
-                                       (emojify-default-font-height)))
-                                    ((equal target 'mode-line)
-                                     (emojify-face-height 'mode-line))
-                                    (t (with-current-buffer buffer
-                                         (emojify-default-font-height)))))))))
-
-(defun emojify--get-unicode-display (data &rest ignored)
-  "Get the display text property to display the emoji as an unicode character.
-
-DATA holds the emoji data, rest of the arguments IGNORED are ignored"
-  (let* ((unicode (ht-get data "unicode"))
-         (characters (when unicode
-                       (string-to-vector unicode))))
-    (when (seq-every-p #'char-displayable-p characters)
-      unicode)))
-
-(defun emojify--get-ascii-display (data &rest ignored)
-  "Get the display text property to display the emoji as an ascii characters.
-
-DATA holds the emoji data, rest of the arguments IGNORED are ignored."
-  (ht-get data "ascii"))
-
-(defun emojify--get-text-display-props (emoji buffer beg end &optional target)
-  "Get the display property for an EMOJI.
-
-BUFFER is the buffer currently holding the EMOJI, BEG and END delimit the region
-containing the emoji.  TARGET can either be a buffer object or a special value
-mode-line.  It is used to indicate where EMOJI would be displayed, properties
-like font-height are inherited from TARGET if provided."
-  (funcall (pcase emojify-display-style
-             (`image #'emojify--get-image-display)
-             (`unicode #'emojify--get-unicode-display)
-             (`ascii #'emojify--get-ascii-display))
-           emoji
-           buffer
-           beg
-           end
-           target))
-
-(defun emojify--propertize-text-for-emoji (emoji text buffer start end &optional target)
-  "Display EMOJI for TEXT in BUFFER between START and END.
-
-For explanation of TARGET see the documentation of
-`emojify--get-text-display-props'."
-  (let ((display-prop
-         (emojify--get-text-display-props emoji buffer start end target))
-        (buffer-props (unless target
-                        (list 'emojify-buffer buffer
-                              'emojify-beginning (copy-marker start)
-                              'emojify-end (copy-marker end)
-                              'yank-handler (list nil text)
-                              'keymap emojify-emoji-keymap
-                              'help-echo #'emojify-help-function))))
-    (when display-prop
-      (add-text-properties start
-                           end
-                           (append (list 'emojified t
-                                         'emojify-display display-prop
-                                         'display display-prop
-                                         'emojify-text text)
-                                   buffer-props)))))
-
-(defun emojify-display-emojis-in-region (beg end)
-  "Display emojis in region.
-
-BEG and END are the beginning and end of the region respectively.
-
-Displaying happens in two phases, first search based phase displays actual text
-appearing in buffer as emojis.  In the next phase composed text is searched for
-emojis and displayed.
-
-A minor problem here is that if the text is composed after this display loop it
-would not be displayed as emoji, although in practice the two packages that use
-the composition property `prettify-symbol-mode' and `org-bullets' use the
-font-lock machinery which runs before emojify's display loop, so hopefully this
-should not be a problem 🤞."
-  (emojify-with-saved-buffer-state
-    ;; Make sure we halt if displaying emojis takes more than a second (this
-    ;; might be too large duration)
-    (with-timeout (1 (emojify-message "Failed to display emojis under 1 second"))
-      (seq-doseq (regexp (apply #'append
-                                (when emojify--user-emojis-regexp
-                                  (list emojify--user-emojis-regexp))
-                                (list emojify-regexps)))
-        (let (case-fold-search)
-          (goto-char beg)
-          (while (and (> end (point))
-                      (search-forward-regexp regexp end t))
-            (let* ((match-beginning (match-beginning 0))
-                   (match-end (match-end 0))
-                   (match (match-string-no-properties 0))
-                   (buffer (current-buffer))
-                   (emoji (emojify-get-emoji match))
-                   (force-display (get-text-property match-beginning 'emojify-force-display)))
-              (when (and emoji
-                         (not (or (get-text-property match-beginning 'emojify-inhibit)
-                                  (get-text-property match-end 'emojify-inhibit)))
-                         (memql (intern (ht-get emoji "style"))
-                                emojify-emoji-styles)
-                         ;; Skip displaying this emoji if the its bounds are
-                         ;; already part of an existing emoji. Since the emojis
-                         ;; are searched in descending order of length (see
-                         ;; construction of emojify-regexp in `emojify-set-emoji-data'),
-                         ;; this means larger emojis get precedence over smaller
-                         ;; ones
-                         (not (or (get-text-property match-beginning 'emojified)
-                                  (get-text-property (1- match-end) 'emojified)))
-                         ;; Display unconditionally in non-prog mode
-                         (or (not (derived-mode-p 'prog-mode 'tuareg--prog-mode 'comint-mode 'smalltalk-mode))
-                             ;; In prog mode enable respecting `emojify-program-contexts'
-                             (emojify-valid-program-context-p emoji match-beginning match-end))
-
-                         ;; Display ascii emojis conservatively, since they have potential
-                         ;; to be annoying consider d: in head:, except while executing apropos
-                         ;; emoji
-                         (or (not (string= (ht-get emoji "style") "ascii"))
-                             force-display
-                             (emojify-valid-ascii-emoji-context-p match-beginning match-end))
-
-                         (or force-display
-                             (not (emojify-inside-org-src-p match-beginning)))
-
-                         ;; Inhibit possibly inside a list
-                         ;; 41 is ?) but packages get confused by the extra closing paren :)
-                         ;; TODO Report bugs to such packages
-                         (or force-display
-                             (not (and (eq (char-syntax (char-before match-end)) 41)
-                                       (emojify-looking-at-end-of-list-maybe match-end))))
-
-                         (not (run-hook-with-args-until-success 'emojify-inhibit-functions match match-beginning match-end)))
-                (emojify--propertize-text-for-emoji emoji match buffer match-beginning match-end)))
-            ;; Stop a bit to let `with-timeout' kick in
-            (sit-for 0 t))))
-
-      ;; Loop to emojify composed text
-      (when (and emojify-composed-text-p
-                 ;; Skip this if user has disabled unicode style emojis, since
-                 ;; we display only composed text that are unicode emojis
-                 (memql 'unicode emojify-emoji-styles))
-        (goto-char beg)
-        (let ((compose-start (if (get-text-property beg 'composition)
-                                 ;; Check `beg' first for composition property
-                                 ;; since `next-single-property-change' will
-                                 ;; search for region after `beg' for property
-                                 ;; change thus skipping any composed text at
-                                 ;; `beg'
-                                 beg
-                               (next-single-property-change beg
-                                                            'composition
-                                                            nil
-                                                            end))))
-          (while (and (> end (point))
-                      ;; `end' would be equal to `compose-start' if there was no
-                      ;; text with composition found within `end', this happens
-                      ;; because `next-single-property-change' returns the limit
-                      ;; (and we use `end' as the limit) if no match is found
-                      (> end compose-start)
-                      compose-start)
-            (let* ((match (emojify--get-composed-text compose-start))
-                   (emoji (emojify-get-emoji match))
-                   (compose-end (next-single-property-change compose-start 'composition nil end)))
-              ;; Display only composed text that is unicode char
-              (when (and emoji
-                         (string= (ht-get emoji "style") "unicode"))
-                (emojify--propertize-text-for-emoji emoji match (current-buffer) compose-start compose-end))
-              ;; Setup the next loop
-              (setq compose-start (and compose-end (next-single-property-change compose-end
-                                                                                'composition
-                                                                                nil
-                                                                                end)))
-              (goto-char compose-end))
-            ;; Stop a bit to let `with-timeout' kick in
-            (sit-for 0 t)))))))
-
-(defun emojify-undisplay-emojis-in-region (beg end)
-  "Undisplay the emojis in region.
-
-BEG and END are the beginning and end of the region respectively"
-  (emojify-with-saved-buffer-state
-    (while (< beg end)
-      ;; Get the start of emojified region in the region, the region is marked
-      ;; with text-property `emojified' whose value is `t'. The region is marked
-      ;; so that we do not inadvertently remove display or other properties
-      ;; inserted by other packages.  This might fail too if a package adds any
-      ;; of these properties between an emojified text, but that situation is
-      ;; hopefully very rare and this is better than blindly removing all text
-      ;; properties
-      (let* ((emoji-start (text-property-any beg end 'emojified t))
-             ;; Get the end emojified text, if we could not find the start set
-             ;; emoji-end to region `end', this merely to make looping easier.
-             (emoji-end (or (and emoji-start
-                                 (text-property-not-all emoji-start end 'emojified t))
-                            ;; If the emojified text is at the end of the region
-                            ;; assume that end is the emojified text.
-                            end)))
-        ;; Proceed only if we got start of emojified text
-        (when emoji-start
-          ;; Remove the properties
-          (remove-text-properties emoji-start emoji-end (append (list 'emojified t
-                                                                      'display t
-                                                                      'emojify-display t
-                                                                      'emojify-buffer t
-                                                                      'emojify-text t
-                                                                      'emojify-beginning t
-                                                                      'emojify-end t
-                                                                      'yank-handler t
-                                                                      'keymap t
-                                                                      'help-echo t
-                                                                      'rear-nonsticky t))))
-        ;; Setup the next iteration
-        (setq beg emoji-end)))))
-
-(defun emojify-redisplay-emojis-in-region (&optional beg end)
-  "Redisplay emojis in region between BEG and END.
-
-Redisplay emojis in the visible region if BEG and END are not specified"
-  (let* ((area (emojify--get-relevant-region))
-         (beg (save-excursion
-                (goto-char (or beg (car area)))
-                (line-beginning-position)))
-         (end (save-excursion
-                (goto-char (or end (cdr area)))
-                (line-end-position))))
-    (unless (> (- end beg) 5000)
-      (emojify-execute-ignoring-errors-unless-debug
-        (emojify-undisplay-emojis-in-region beg end)
-        (emojify-display-emojis-in-region beg end)))))
-
-(defun emojify-after-change-extend-region-function (beg end _len)
-  "Extend the region to be emojified.
-
-This simply extends the region to be fontified to the start of line at BEG and
-end of line at END.  _LEN is ignored.
-
-The idea is since an emoji cannot span multiple lines, redisplaying complete
-lines ensures that all the possibly affected emojis are redisplayed."
-  (let ((emojify-jit-lock-start (save-excursion
-                                  (goto-char beg)
-                                  (line-beginning-position)))
-        (emojify-jit-lock-end (save-excursion
-                                (goto-char end)
-                                (line-end-position))))
-    (setq jit-lock-start (if jit-lock-start
-                             (min jit-lock-start emojify-jit-lock-start)
-                           emojify-jit-lock-start))
-    (setq jit-lock-end (if jit-lock-end
-                           (max jit-lock-end emojify-jit-lock-end)
-                         emojify-jit-lock-end))))
-
-
-
-;; Emojify standalone strings
-
-(defun emojify-string (string &optional styles target)
-  "Create a propertized version of STRING, to display emojis belonging STYLES.
-
-TARGET can either be a buffer object or a special value mode-line.  It is used
-to indicate where EMOJI would be displayed, properties like font-height are
-inherited from TARGET if provided.  See also `emojify--get-text-display-props'."
-  (emojify-create-emojify-emojis)
-  (let ((target (or target (current-buffer))))
-    (with-temp-buffer
-      (insert string)
-      (let ((beg (point-min))
-            (end (point-max))
-            (styles (or styles '(unicode))))
-        (seq-doseq (regexp (apply #'append
-                                  (when emojify--user-emojis-regexp
-                                    (list emojify--user-emojis-regexp))
-                                  (list emojify-regexps)))
-          (goto-char beg)
-          (while (and (> end (point))
-                      (search-forward-regexp regexp end t))
-            (let* ((match-beginning (match-beginning 0))
-                   (match-end (match-end 0))
-                   (match (match-string-no-properties 0))
-                   (buffer (current-buffer))
-                   (emoji (emojify-get-emoji match)))
-              (when (and emoji
-                         (not (or (get-text-property match-beginning 'emojify-inhibit)
-                                  (get-text-property match-end 'emojify-inhibit)))
-                         (memql (intern (ht-get emoji "style")) styles)
-                         ;; Skip displaying this emoji if the its bounds are
-                         ;; already part of an existing emoji. Since the emojis
-                         ;; are searched in descending order of length (see
-                         ;; construction of emojify-regexp in `emojify-set-emoji-data'),
-                         ;; this means larger emojis get precedence over smaller
-                         ;; ones
-                         (not (or (get-text-property match-beginning 'emojified)
-                                  (get-text-property (1- match-end) 'emojified))))
-                (emojify--propertize-text-for-emoji emoji match buffer match-beginning match-end target))))))
-      (buffer-string))))
-
-
-
-;; Electric delete functionality
-
-(defun emojify--find-key-binding-ignoring-emojify-keymap (key)
-  "Find the binding for given KEY ignoring the text properties at point.
-
-This is needed since `key-binding' looks up in keymap text property as well
-which is not what we want when falling back in `emojify-delete-emoji'"
-  (let* ((key-binding (or (minor-mode-key-binding key)
-                          (local-key-binding key)
-                          (global-key-binding key))))
-    (when key-binding
-      (or (command-remapping key-binding
-                             nil
-                             (seq-filter (lambda (keymap)
-                                           (not (equal keymap emojify-emoji-keymap)))
-                                         (current-active-maps)))
-          key-binding))))
-
-(defun emojify-delete-emoji (point)
-  "Delete emoji at POINT."
-  (if (get-text-property point 'emojified)
-      (delete-region (get-text-property point 'emojify-beginning)
-                     (get-text-property point 'emojify-end))
-    (call-interactively (emojify--find-key-binding-ignoring-emojify-keymap (this-command-keys)))))
-
-(defun emojify-delete-emoji-forward ()
-  "Delete emoji after point."
-  (interactive)
-  (emojify-delete-emoji (point)))
-
-(defun emojify-delete-emoji-backward ()
-  "Delete emoji before point."
-  (interactive)
-  (emojify-delete-emoji (1- (point))))
-
-;; Integrate with delete-selection-mode
-;; Basically instruct delete-selection mode to override our commands
-;; if the region is active.
-(put 'emojify-delete-emoji-forward 'delete-selection 'supersede)
-(put 'emojify-delete-emoji-backward 'delete-selection 'supersede)
-
-
-
-;; Updating background color on selection
-
-(defun emojify--update-emojis-background-in-region (&optional beg end)
-  "Update the background color for emojis between BEG and END."
-  (when (equal emojify-display-style 'image)
-    (emojify-with-saved-buffer-state
-      (emojify-do-for-emojis-in-region beg end
-        (plist-put (cdr (get-text-property emoji-start 'display))
-                   :background
-                   (emojify--get-image-background emoji-start
-                                                  emoji-end))))))
-
-(defun emojify--update-emojis-background-in-region-starting-at (point)
-  "Update background color for emojis in buffer starting at POINT.
-
-This updates the emojis in the region starting from POINT, the end of region is
-determined by product of `frame-height' and `frame-width' which roughly
-corresponds to the visible area.  POINT usually corresponds to the starting
-position of the window, see
-`emojify-update-visible-emojis-background-after-command' and
-`emojify-update-visible-emojis-background-after-window-scroll'
-
-NOTE: `window-text-height' and `window-text-width' would have been more
-appropriate here however they were not defined in Emacs v24.3 and below."
-  (let* ((region-beginning point)
-         (region-end (min (+ region-beginning (* (frame-height)
-                                                 (frame-width)))
-                          (point-max))))
-    (emojify--update-emojis-background-in-region region-beginning
-                                                 region-end)))
-
-(defun emojify-update-visible-emojis-background-after-command ()
-  "Function added to `post-command-hook' when region is active.
-
-This function updates the backgrounds of the emojis in the region changed after
-the command.
-
-Ideally this would have been good enough to update emoji backgounds after region
-changes, unfortunately this does not work well with commands that scroll the
-window specifically `window-start' and `window-end' (sometimes only `window-end')
-report incorrect values.
-
-To work around this
-`emojify-update-visible-emojis-background-after-window-scroll' is added to
-`window-scroll-functions' to update emojis on window scroll."
-  (while-no-input (emojify--update-emojis-background-in-region-starting-at (window-start))))
-
-(defun emojify-update-visible-emojis-background-after-window-scroll (_window display-start)
-  "Function added to `window-scroll-functions' when region is active.
-
-This function updates the backgrounds of the emojis in the newly displayed area
-of the window.  DISPLAY-START corresponds to the new start of the window."
-  (while-no-input (emojify--update-emojis-background-in-region-starting-at display-start)))
-
-
-
-;; Lazy image downloading
-
-(defcustom emojify-download-emojis-p 'ask
-  "Should emojify download images, if the selected emoji sets are not available.
-
-Emojify can automatically download the images required to display the selected
-emoji set.  By default the user will be asked for confirmation before downloading
-the image.  Set this variable to t to download the images without asking for
-confirmation.  Setting it to nil will disable automatic download of the images.
-
-Please note that emojify will not download the images if Emacs is running in
-non-interactive mode and `emojify-download-emojis-p' is set to `ask'."
-  :type '(radio :tag "Automatically download required images"
-                (const :tag "Ask before downloading" ask)
-                (const :tag "Download without asking" t)
-                (const :tag "Disable automatic downloads" nil))
-  :group 'emojify)
-
-(defvar emojify--refused-image-download-p nil
-  "Used to remember that user has refused to download images in this session.")
-(defvar emojify--download-in-progress-p nil
-  "Is emoji download in progress used to avoid multiple emoji download prompts.")
-
-(defun emojify--emoji-download-emoji-set (data)
-  "Download the emoji images according to DATA."
-  (let ((destination (expand-file-name (make-temp-name "emojify")
-                                       temporary-file-directory)))
-    (url-copy-file (ht-get data "url")
-                   destination)
-    (let ((downloaded-sha (with-temp-buffer
-                            (insert-file-contents-literally destination)
-                            (secure-hash 'sha256 (current-buffer)))))
-      (when (string= downloaded-sha (ht-get data "sha256"))
-        destination))))
-
-(defun emojify--extract-emojis (file)
-  "Extract the tar FILE in emoji directory."
-  (let* ((default-directory emojify-emojis-dir))
-    (with-temp-buffer
-      (insert-file-contents-literally file)
-      (let ((emojify-inhibit-emojify-in-current-buffer-p t))
-        (tar-mode))
-      (tar-untar-buffer))))
-
-(defun emojify-download-emoji (emoji-set)
-  "Download the provided EMOJI-SET."
-  (interactive (list (completing-read "Select the emoji set you want to download: "
-                                      (ht-keys emojify-emoji-set-json))))
-  (let ((emoji-data (ht-get emojify-emoji-set-json emoji-set)))
-    (cond ((not emoji-data)
-           (error "No emoji set named %s found" emoji-set))
-          ((and (file-exists-p (expand-file-name emoji-set emojify-emojis-dir))
-                (called-interactively-p 'any))
-           (message "%s emoji-set already downloaded, not downloading again!" emoji-set))
-          (t
-           (emojify--extract-emojis (emojify--emoji-download-emoji-set (ht-get emojify-emoji-set-json emoji-set)))))))
-
-(defun emojify--confirm-emoji-download ()
-  "Confirm download of emojis.
-
-This takes care of respecting the `emojify-download-emojis-p' and making sure we
-do not prompt the user to download emojis multiple times."
-  (if (not (equal emojify-download-emojis-p 'ask))
-      emojify-download-emojis-p
-    ;; Skip the prompt if we are in noninteractive mode or the user has already
-    ;; denied us permission to download once
-    (unless (or noninteractive emojify--refused-image-download-p)
-      (let ((download-confirmed-p (yes-or-no-p "[emojify] Emoji images not available should I download them now?")))
-        (setq emojify--refused-image-download-p (not download-confirmed-p))
-        download-confirmed-p))))
-
-(defun emojify-download-emoji-maybe ()
-  "Download emoji images if needed."
-  (when (and (equal emojify-display-style 'image)
-             (not (file-exists-p (emojify-image-dir)))
-             (not emojify--refused-image-download-p))
-    (unwind-protect
-        ;; Do not prompt for download if download is in progress
-        (unless emojify--download-in-progress-p
-          (setq emojify--download-in-progress-p t)
-          (if (emojify--confirm-emoji-download)
-              (emojify-download-emoji emojify-emoji-set)
-            (warn "[emojify] Not downloading emoji images for now. Emojis would
-not be displayed since images are not available. If you wish to download emojis,
-run the command `emojify-download-emoji'")))
-      (setq emojify--download-in-progress-p nil))))
-
-(defun emojify-ensure-images ()
-  "Ensure that emoji images are downloaded."
-  (if after-init-time
-      (emojify-download-emoji-maybe)
-    (add-hook 'after-init-hook #'emojify-download-emoji-maybe t)))
-
-
-
-;; Minor mode definitions
-
-(defun emojify-turn-on-emojify-mode ()
-  "Turn on `emojify-mode' in current buffer."
-
-  ;; Calculate emoji data if needed
-  (emojify-create-emojify-emojis)
-
-  (when (emojify-buffer-p (current-buffer))
-    ;; Download images if not available
-    (emojify-ensure-images)
-
-    ;; Install our jit-lock function
-    (jit-lock-register #'emojify-redisplay-emojis-in-region)
-    (add-hook 'jit-lock-after-change-extend-region-functions #'emojify-after-change-extend-region-function t t)
-
-    ;; Handle point entered behaviour
-    (add-hook 'post-command-hook #'emojify-detect-emoji-entry/exit t t)
-
-    ;; Update emoji backgrounds after each command
-    (add-hook 'post-command-hook #'emojify-update-visible-emojis-background-after-command t t)
-
-    ;; Update emoji backgrounds after mark is deactivated, this is needed since
-    ;; deactivation can happen outside the command loop
-    (add-hook 'deactivate-mark-hook #'emojify-update-visible-emojis-background-after-command t t)
-
-    ;; Update emoji backgrounds after when window scrolls
-    (add-hook 'window-scroll-functions #'emojify-update-visible-emojis-background-after-window-scroll t t)
-
-    ;; Redisplay emojis after enabling `prettify-symbol-mode'
-    (add-hook 'prettify-symbols-mode-hook #'emojify-redisplay-emojis-in-region)
-
-    ;; Redisplay visible emojis when emoji style changes
-    (add-hook 'emojify-emoji-style-change-hook #'emojify-redisplay-emojis-in-region)))
-
-(defun emojify-turn-off-emojify-mode ()
-  "Turn off `emojify-mode' in current buffer."
-  ;; Remove currently displayed emojis
-  (save-restriction
-    (widen)
-    (emojify-undisplay-emojis-in-region (point-min) (point-max)))
-
-  ;; Uninstall our jit-lock function
-  (jit-lock-unregister #'emojify-redisplay-emojis-in-region)
-  (remove-hook 'jit-lock-after-change-extend-region-functions #'emojify-after-change-extend-region-function t)
-
-  (remove-hook 'post-command-hook #'emojify-detect-emoji-entry/exit t)
-
-  ;; Disable hooks to update emoji backgrounds
-  (remove-hook 'post-command-hook #'emojify-update-visible-emojis-background-after-command t)
-  (remove-hook 'deactivate-mark-hook #'emojify-update-visible-emojis-background-after-command t)
-  (remove-hook 'window-scroll-functions #'emojify-update-visible-emojis-background-after-window-scroll t)
-
-  ;; Remove hook to redisplay emojis after enabling `prettify-symbol-mode'
-  (remove-hook 'prettify-symbols-mode-hook #'emojify-redisplay-emojis-in-region)
-
-  ;; Remove style change hooks
-  (remove-hook 'emojify-emoji-style-change-hook #'emojify-redisplay-emojis-in-region))
-
-;;;###autoload
-(define-minor-mode emojify-mode
-  "Emojify mode"
-  :init-value nil
-  (if emojify-mode
-      ;; Turn on
-      (emojify-turn-on-emojify-mode)
-    ;; Turn off
-    (emojify-turn-off-emojify-mode)))
-
-;;;###autoload
-(define-globalized-minor-mode global-emojify-mode
-  emojify-mode emojify-mode
-  :init-value nil)
-
-(defadvice set-buffer-multibyte (after emojify-disable-for-unibyte-buffers (&rest ignored))
-  "Disable emojify when unibyte encoding is enabled for a buffer.
-Re-enable it when buffer changes back to multibyte encoding."
-  (ignore-errors
-    (if enable-multibyte-characters
-        (when global-emojify-mode
-          (emojify-mode +1))
-      (emojify-mode -1))))
-
-(ad-activate #'set-buffer-multibyte)
-
-
-
-;; Displaying emojis in mode-line
-
-(defun emojify--emojied-mode-line (format)
-  "Return an emojified version of mode-line FORMAT.
-
-The format is converted to the actual string to be displayed using
-`format-mode-line' and the unicode characters are replaced by images."
-  (if emojify-mode
-      ;; Remove "%e" from format since we keep it as first part of the
-      ;; emojified mode-line, see `emojify-emojify-mode-line'
-      (emojify-string (format-mode-line (delq "%e" format)) nil 'mode-line)
-    (format-mode-line format)))
-
-(defun emojify-mode-line-emojified-p ()
-  "Check if the mode-line is already emojified.
-
-If the `mode-line-format' is of following format
-
-\(\"%e\" (:eval (emojify-emojied-mode-line ... )))
-
-We can assume the mode-line is already emojified."
-  (and (consp mode-line-format)
-       (equal (ignore-errors (cl-caadr mode-line-format))
-              :eval)
-       (equal (ignore-errors (car (cl-cadadr mode-line-format)))
-              'emojify--emojied-mode-line)))
-
-(defun emojify-emojify-mode-line ()
-  "Emojify unicode characters in the mode-line.
-
-This updates `mode-line-format' to a modified version which emojifies the
-mode-line before it is displayed."
-  (unless (emojify-mode-line-emojified-p)
-    (setq mode-line-format `("%e" (:eval
-                                   (emojify--emojied-mode-line ',mode-line-format))))))
-
-(defun emojify-unemojify-mode-line ()
-  "Restore `mode-line-format' to unemojified version.
-
-This basically reverses the effect of `emojify-emojify-mode-line'."
-  (when (emojify-mode-line-emojified-p)
-    (setq mode-line-format (cl-cadadr (cl-cadadr mode-line-format)))))
-
-;;;###autoload
-(define-minor-mode emojify-mode-line-mode
-  "Emojify mode line"
-  :init-value nil
-  (if emojify-mode-line-mode
-      ;; Turn on
-      (emojify-emojify-mode-line)
-    ;; Turn off
-    (emojify-unemojify-mode-line)))
-
-;;;###autoload
-(define-globalized-minor-mode global-emojify-mode-line-mode
-  emojify-mode-line-mode emojify-mode-line-mode
-  :init-value nil)
-
-
-
-;; Searching emojis
-
-(defvar emojify-apropos-buffer-name "*Apropos Emojis*")
-
-(defun emojify-apropos-quit ()
-  "Delete the window displaying Emoji search results."
-  (interactive)
-  (if (= (length (window-list)) 1)
-      (bury-buffer)
-    (quit-window)))
-
-(defun emojify-apropos-copy-emoji ()
-  "Copy the emoji being displayed at current line in apropos results."
-  (interactive)
-  (save-excursion
-    (goto-char (line-beginning-position))
-    (if (not (get-text-property (point) 'emojified))
-        (emojify-user-error "No emoji at point")
-      (kill-new (get-text-property (point) 'emojify-text))
-      (message "Copied emoji (%s) to kill ring!"
-               (get-text-property (point) 'emojify-text)))))
-
-(defun emojify-apropos-describe-emoji ()
-  "Copy the emoji being displayed at current line in apropos results."
-  (interactive)
-  (save-excursion
-    (goto-char (line-beginning-position))
-    (if (not (get-text-property (point) 'emojified))
-        (emojify-user-error "No emoji at point")
-      (emojify-describe-emoji (get-text-property (point) 'emojify-text)))))
-
-(defvar emojify-apropos-mode-map
-  (let ((map (make-sparse-keymap)))
-    (set-keymap-parent map emojify-common-mode-map)
-    (define-key map "c" #'emojify-apropos-copy-emoji)
-    (define-key map "w" #'emojify-apropos-copy-emoji)
-    (define-key map "d" #'emojify-apropos-describe-emoji)
-    (define-key map (kbd "RET") #'emojify-apropos-describe-emoji)
-    (define-key map "g" #'emojify-apropos-emoji)
-    map)
-  "Keymap used in `emojify-apropos-mode'.")
-
-(define-derived-mode emojify-apropos-mode fundamental-mode "Apropos Emojis"
-  "Mode used to display results of `emojify-apropos-emoji'
-
-\\{emojify-apropos-mode-map}"
-  (emojify-mode +1)
-  ;; view mode being a minor mode eats up our bindings avoid it
-  (let (view-read-only)
-    (read-only-mode +1)))
-
-(put 'emojify-apropos-mode 'mode-class 'special)
-
-(defvar emojify--apropos-last-query nil)
-(make-variable-buffer-local 'emojify--apropos-last-query)
-
-(defun emojify-apropos-read-pattern ()
-  "Read apropos pattern with INITIAL-INPUT as the initial input.
-
-Borrowed from apropos.el"
-  (let ((pattern (read-string (concat "Search for emoji (word list or regexp): ")
-                              emojify--apropos-last-query)))
-    (if (string-equal (regexp-quote pattern) pattern)
-        (or (split-string pattern "[ \t]+" t)
-            (emojify-user-error "No word list given"))
-      pattern)))
-
-;;;###autoload
-(defun emojify-apropos-emoji (pattern)
-  "Show Emojis that match PATTERN."
-  (interactive (list (emojify-apropos-read-pattern)))
-
-  (emojify-create-emojify-emojis)
-
-  (let ((in-apropos-buffer-p (equal major-mode 'emojify-apropos-mode))
-        matching-emojis
-        sorted-emojis)
-
-    (unless (listp pattern)
-      (setq pattern (list pattern)))
-
-    ;; Convert the user entered text to a regex to match the emoji name or
-    ;; description
-    (apropos-parse-pattern pattern)
-
-    ;; Collect matching emojis in a list of (list score emoji emoji-data)
-    ;; elements, where score is the proximity of the emoji to given pattern
-    ;; calculated using `apropos-score-str'
-    (emojify-emojis-each (lambda (key value)
-                           (when (or (string-match apropos-regexp key)
-                                     (string-match apropos-regexp (ht-get value "name")))
-                             (push (list (max (apropos-score-str key)
-                                              (apropos-score-str (ht-get value "name")))
-                                         key
-                                         value)
-                                   matching-emojis))))
-
-    ;; Sort the emojis by the proximity score
-    (setq sorted-emojis (mapcar #'cdr
-                                (sort matching-emojis
-                                      (lambda (emoji1 emoji2)
-                                        (> (car emoji1) (car emoji2))))))
-
-    ;; Insert result in apropos buffer and display it
-    (with-current-buffer (get-buffer-create emojify-apropos-buffer-name)
-      (let ((inhibit-read-only t)
-            (query (mapconcat 'identity pattern " ")))
-        (erase-buffer)
-        (insert (propertize "Emojis matching" 'face 'apropos-symbol))
-        (insert (format " - \"%s\"" query))
-        (insert "\n\nUse `c' or `w' to copy emoji on current line\nUse `g' to rerun apropos\n\n")
-        (dolist (emoji sorted-emojis)
-          (insert (format "%s - %s (%s)"
-                          (car emoji)
-                          (ht-get (cadr emoji) "name")
-                          (ht-get (cadr emoji) "style")))
-          (insert "\n"))
-        (goto-char (point-min))
-        (forward-line (1- 6))
-        (emojify-apropos-mode)
-        (setq emojify--apropos-last-query (concat query " "))
-        (setq-local line-spacing 7)))
-
-    (pop-to-buffer (get-buffer emojify-apropos-buffer-name)
-                   (when in-apropos-buffer-p
-                     (cons #'display-buffer-same-window nil)))))
-
-
-
-;; Inserting emojis
-
-(defun emojify--completing-read-minibuffer-setup-hook ()
-  "Enables `emojify-mode' in minbuffer while inserting emojis.
-
-This ensures `emojify' is enabled even when `global-emojify-mode' is not on."
-  (emojify-mode +1))
-
-(defun emojify--completing-read-helm-hook ()
-  "Enables `emojify-mode' in helm buffer.
-
-This ensures `emojify' is enabled in helm buffer displaying completion even when
-`global-emojify-mode' is not on."
-  (with-current-buffer helm-buffer
-    (emojify-mode +1)))
-
-(defun emojify-completing-read (prompt &optional predicate require-match initial-input hist def inherit-input-method)
-  "Read emoji from the user and return the selected emoji.
-
-PROMPT is a string to prompt with, PREDICATE, REQUIRE-MATCH, INITIAL-INPUT,
-HIST, DEF, INHERIT-INPUT-METHOD correspond to the arguments for
-`completing-read' and are passed to ‘completing-read’ without any
-interpretation.
-
-For each possible emoji PREDICATE is called with emoji text and data about the
-emoji as a hash-table, the predate should return nil if it the emoji should
-not be displayed for selection.
-
-For example the following can be used to display only github style emojis for
-selection
-
-\(emojify-completing-read \"Select a Github style emoji: \"
-                         (lambda (emoji data)
-                           (equal (gethash \"style\" data) \"github\")))
-
-This function sets up `ido', `icicles', `helm', `ivy' and vanilla Emacs
-completion UI to display properly emojis."
-  (emojify-create-emojify-emojis)
-  (let* ((emojify-minibuffer-reading-emojis-p t)
-         (line-spacing 7)
-         (completion-ignore-case t)
-         (candidates (emojify--get-completing-read-candidates))
-         ;; Vanilla Emacs completion and Icicles use the completion list mode to display candidates
-         ;; the following makes sure emojify is enabled in the completion list
-         (completion-list-mode-hook (cons #'emojify--completing-read-minibuffer-setup-hook
-                                          completion-list-mode-hook))
-         ;; (Vertical) Ido and Ivy displays candidates in minibuffer this makes sure candidates are emojified
-         ;; when Ido or Ivy are used
-         (minibuffer-setup-hook (cons #'emojify--completing-read-minibuffer-setup-hook
-                                      minibuffer-setup-hook))
-         (helm-after-initialize-hook (cons #'emojify--completing-read-helm-hook
-                                           (bound-and-true-p helm-after-initialize-hook))))
-    (car (split-string (completing-read prompt
-                                        candidates
-                                        predicate
-                                        require-match
-                                        initial-input
-                                        hist
-                                        def
-                                        inherit-input-method)
-                       " "))))
-
-;;;###autoload
-(defun emojify-insert-emoji ()
-  "Interactively prompt for Emojis and insert them in the current buffer.
-
-This respects the `emojify-emoji-styles' variable."
-  (interactive)
-  (insert (emojify-completing-read "Insert Emoji: ")))
-
-
-
-;; Describing emojis
-
-(defvar emojify-help-buffer-name "*Emoji Help*")
-
-(defvar-local emojify-described-emoji nil)
-
-(defun emojify-description-copy-emoji ()
-  "Copy the emoji being displayed at current line in apropos results."
-  (interactive)
-  (save-excursion
-    (kill-new emojify-described-emoji)
-    (message "Copied emoji (%s) to kill ring!" emojify-described-emoji)))
-
-(defvar emojify-description-mode-map
-  (let ((map (make-sparse-keymap)))
-    (set-keymap-parent map emojify-common-mode-map)
-    (define-key map "c" #'emojify-description-copy-emoji)
-    (define-key map "w" #'emojify-description-copy-emoji)
-    map)
-  "Keymap used in `emojify-description-mode'.")
-
-(define-derived-mode emojify-description-mode fundamental-mode "Describe Emoji"
-  "Mode used to display results of description for emojis.
-
-\\{emojify-description-mode-map}"
-  (emojify-mode +1)
-  ;; view mode being a minor mode eats up our bindings avoid it
-  (let (view-read-only)
-    (read-only-mode +1))
-  (goto-address-mode +1))
-
-(put 'emojify-description-mode 'mode-class 'special)
-
-(defun emojify--display-emoji-description-buffer (emoji)
-  "Display description for EMOJI."
-  (with-current-buffer (get-buffer-create emojify-help-buffer-name)
-    (let ((inhibit-read-only t))
-      (erase-buffer)
-      (save-excursion
-        (insert (propertize (ht-get emoji "emoji") 'emojify-inhibit t)
-                " - Displayed as "
-                (propertize (ht-get emoji "emoji") 'emojify-force-display t)
-                "\n\n")
-        (insert (propertize "Name" 'face 'font-lock-keyword-face)
-                ": "
-                (ht-get emoji "name") "\n")
-        (insert (propertize "Style" 'face 'font-lock-keyword-face)
-                ": "
-                (ht-get emoji "style") "\n")
-        (insert (propertize "Image used" 'face 'font-lock-keyword-face)
-                ": "
-                (expand-file-name (ht-get emoji "image")
-                                  (emojify-image-dir))
-                "\n")
-        (when (and (not (string= (ht-get emoji "style") "unicode"))
-                   (ht-get emoji "unicode"))
-          (insert (propertize "Unicode representation"
-                              'face 'font-lock-keyword-face)
-                  ": "
-                  (propertize (ht-get emoji "unicode") 'emojify-inhibit t)
-                  "\n"))
-        (when (and (not (string= (ht-get emoji "style") "ascii"))
-                   (ht-get emoji "ascii"))
-          (insert (propertize "Ascii representation"
-                              'face 'font-lock-keyword-face)
-                  ": "
-                  (propertize (ht-get emoji "ascii") 'emojify-inhibit t)
-                  "\n"))
-        (insert (propertize "User defined"
-                            'face 'font-lock-keyword-face)
-                ": "
-                (if (ht-get emoji "custom") "Yes" "No")
-                "\n")
-        (unless (ht-get emoji "custom")
-          (when (or (ht-get emoji "unicode")
-                    (string= (ht-get emoji "style") "unicode"))
-            (insert (propertize "Unicode Consortium" 'face 'font-lock-keyword-face)
-                    ": "
-                    (concat "http://www.unicode.org/emoji/charts-beta/full-emoji-list.html#"
-                            (string-join (mapcar (apply-partially #'format "%x")
-                                                 (string-to-list (or (ht-get emoji "unicode")
-                                                                     (ht-get emoji "emoji"))))
-                                         "_"))
-                    "\n"))
-          (insert (propertize "Emojipedia" 'face 'font-lock-keyword-face)
-                  ": "
-                  (let* ((tone-stripped (replace-regexp-in-string "- *[Tt]one *\\([0-9]+\\)$"
-                                                                  "- type \\1"
-                                                                  (ht-get emoji "name")))
-                         (non-alphanumeric-stripped (replace-regexp-in-string "[^0-9a-zA-Z]"
-                                                                              " "
-                                                                              tone-stripped))
-                         (words (split-string non-alphanumeric-stripped " " t " ")))
-                    (concat "http://emojipedia.org/"
-                            (downcase (emojify--string-join words "-"))))
-                  "\n"))))
-    (emojify-description-mode)
-    (setq emojify-described-emoji (ht-get emoji "emoji")))
-  (display-buffer (get-buffer emojify-help-buffer-name))
-  (get-buffer emojify-help-buffer-name))
-
-(defun emojify-describe-emoji (emoji-text)
-  "Display description for EMOJI-TEXT."
-  (interactive (list (emojify-completing-read "Describe Emoji: ")))
-  (if (emojify-get-emoji emoji-text)
-      (emojify--display-emoji-description-buffer (emojify-get-emoji emoji-text))
-    (emojify-user-error "No emoji found for '%s'" emoji-text)))
-
-(defun emojify-describe-emoji-at-point ()
-  "Display help for EMOJI displayed at point."
-  (interactive)
-  (if (not (get-text-property (point) 'emojified))
-      (emojify-user-error "No emoji at point!")
-    (emojify--display-emoji-description-buffer (emojify-get-emoji (get-text-property (point) 'emojify-text)))))
-
-
-
-;; Listing emojis
-
-(defun emojify-list-copy-emoji ()
-  "Copy the emoji being displayed at current line in apropos results."
-  (interactive)
-  (save-excursion
-    (let ((emoji (get-text-property (point) 'tabulated-list-id)))
-      (if (not emoji)
-          (emojify-user-error "No emoji at point")
-        (kill-new emoji)
-        (message "Copied emoji (%s) to kill ring!" emoji)))))
-
-(defun emojify-list-describe-emoji ()
-  "Copy the emoji being displayed at current line in apropos results."
-  (interactive)
-  (save-excursion
-    (let ((emoji (get-text-property (point) 'tabulated-list-id)))
-      (if (not emoji)
-          (emojify-user-error "No emoji at point")
-        (emojify-describe-emoji emoji)))))
-
-(defvar-local emojify-list--emojis-displayed nil
-  "Record that emojis have been successfully displayed in the current buffer.
-
-`emojify-list-emojis' checks to this decide if it should print the entries
-again.")
-
-(defun emojify-list-force-refresh ()
-  "Force emoji list to be refreshed."
-  (interactive)
-  (setq emojify-list--emojis-displayed nil)
-  (emojify-list-emojis))
-
-(defvar emojify-list-mode-map
-  (let ((map (make-sparse-keymap)))
-    (set-keymap-parent map emojify-common-mode-map)
-    (define-key map "c" #'emojify-list-copy-emoji)
-    (define-key map "w" #'emojify-list-copy-emoji)
-    (define-key map "d" #'emojify-list-describe-emoji)
-    (define-key map "g" #'emojify-list-force-refresh)
-    (define-key map (kbd "RET") #'emojify-list-describe-emoji)
-    map)
-  "Keymap used in `emojify-list-mode'.")
-
-(defun emojify-list-printer (id cols)
-  "Printer used to print the emoji rows in tabulated list.
-
-See `tabulated-list-print-entry' to understand the arguments ID and COLS."
-  (let ((beg (point))
-        (padding (max tabulated-list-padding 0))
-        (inhibit-read-only t))
-    (when (> tabulated-list-padding 0)
-      (insert (make-string padding ?\s)))
-
-    (tabulated-list-print-col 0
-                              (propertize (aref cols 0) 'emojify-inhibit t)
-                              (current-column))
-
-    ;; Inhibit display of second column ("Text") as emoji
-    (tabulated-list-print-col 1
-                              (propertize (aref cols 1) 'emojify-inhibit t)
-                              (current-column))
-
-    ;; The type of this emoji
-    (tabulated-list-print-col 2
-                              (aref cols 2)
-                              (current-column))
-
-    ;; Is this a custom emoji
-    (tabulated-list-print-col 3
-                              (aref cols 3)
-                              (current-column))
-
-    ;; Force display of last column ("Display") as emoji
-    (tabulated-list-print-col 4
-                              (propertize (aref cols 4) 'emojify-force-display t)
-                              (current-column))
-
-    (insert ?\n)
-    (add-text-properties beg
-                         (point)
-                         `(tabulated-list-id ,id tabulated-list-entry ,cols))
-
-    (message "Listing emojis (%d of %d) ..." (1- (line-number-at-pos)) (aref cols 5))))
-
-(defun emojify-list-entries ()
-  "Return entries to display in tabulated list."
-  (emojify-create-emojify-emojis)
-
-  (let (entries count)
-    (emojify-emojis-each (lambda (emoji data)
-                           (push (list emoji (vector (ht-get data "name")
-                                                     emoji
-                                                     (ht-get data "style")
-                                                     (if (ht-get data "custom") "Yes" "No")
-                                                     emoji))
-                                 entries)))
-
-    (setq count (length entries))
-
-    (mapcar (lambda (entry)
-              (list (car entry) (vconcat (cadr entry) (vector count))))
-            entries)))
-
-(define-derived-mode emojify-list-mode tabulated-list-mode "Emoji-List"
-  "Major mode for listing emojis.
-\\{emojify-list-mode-map}"
-  (setq line-spacing 7
-        tabulated-list-format [("Name" 30 t)
-                               ("Text" 20 t)
-                               ("Style" 10 t)
-                               ("Custom" 10 t)
-                               ("Display" 20 nil)]
-        tabulated-list-sort-key (cons "Name" nil)
-        tabulated-list-padding 2
-        tabulated-list-entries #'emojify-list-entries
-        tabulated-list-printer #'emojify-list-printer)
-  (tabulated-list-init-header))
-
-(defun emojify-list-emojis ()
-  "List emojis in a tabulated view."
-  (interactive)
-  (let ((buffer (get-buffer-create "*Emojis*")))
-    (with-current-buffer buffer
-      (unless emojify-list--emojis-displayed
-        (emojify-list-mode)
-        (tabulated-list-print)
-        (setq emojify-list--emojis-displayed t))
-      (pop-to-buffer buffer))))
-
-
-
-;; Integration with company mode
-
-(defadvice company-pseudo-tooltip-unhide (after emojify-display-emojis-in-company-tooltip (&rest ignored))
-  "Advice to display emojis in company mode tooltips.
-
-This function does two things, first it adds text properties to the completion
-tooltip to make it display the emojis, secondly it makes company always render
-the completion tooltip using `after-string' overlay property rather than
-`display' text property.
-
-The second step is needed because emojify displays the emojis using `display'
-text property, similarly company-mode in some cases uses `display' overlay
-property to render its pop, this results into a `display' property inside
-`display' property, however Emacs ignores recursive display text property.
-Using `after-string' works as well as `display' while allowing the emojis to be
-displayed."
-  (when (and emojify-mode
-             emojify-company-tooltips-p
-             (overlayp (bound-and-true-p company-pseudo-tooltip-overlay)))
-    (let* ((ov company-pseudo-tooltip-overlay)
-           (disp (or (overlay-get ov 'display)
-                     (overlay-get ov 'after-string)))
-           (emojified-display (when disp
-                                (emojify-string disp)))
-           (emojified-p (when emojified-display
-                          (text-property-any 0 (1- (length emojified-display))
-                                             'emojified t
-                                             emojified-display))))
-      ;; Do not switch to after-string if menu is not emojified
-      (when (and disp emojified-p)
-        (overlay-put ov 'after-string nil)
-        (overlay-put ov 'display (propertize " " 'invisible t))
-        (overlay-put ov 'after-string emojified-display)))))
-
-(ad-activate #'company-pseudo-tooltip-unhide)
-
-
-
-;; Integration with some miscellaneous functionality
-
-(defadvice mouse--drag-set-mark-and-point (after emojify-update-emoji-background (&rest ignored))
-  "Advice to update emoji backgrounds after selection is changed using mouse.
-
-Currently there are no hooks run after mouse movements, as such the emoji
-backgrounds are updated only after the mouse button is released.  This advices
-`mouse--drag-set-mark-and-point' which is run after selection changes to trigger
-an update of emoji backgrounds.  Not the cleanest but the only way I can think of."
-  (when emojify-mode
-    (emojify-update-visible-emojis-background-after-command)))
-
-(ad-activate #'mouse--drag-set-mark-and-point)
-
-(defadvice text-scale-increase (after emojify-resize-emojis (&rest ignored))
-  "Advice `text-scale-increase' to resize emojis on text resize."
-  (when emojify-mode
-    (let ((new-font-height (emojify-default-font-height)))
-      (emojify-do-for-emojis-in-region (point-min) (point-max)
-        (plist-put (cdr (get-text-property emoji-start 'display))
-                   :height
-                   new-font-height)))))
-
-(ad-activate #'text-scale-increase)
-
-
-
-(provide 'emojify)
-;;; emojify.el ends here