about summary refs log tree commit diff
path: root/configs/shared/emacs/.emacs.d/elpa/yasnippet-20180621.50
diff options
context:
space:
mode:
authorWilliam Carroll <wpcarro@gmail.com>2019-01-13T19·33-0500
committerWilliam Carroll <wpcarro@gmail.com>2019-01-13T19·45-0500
commit481df5a3855ccd5ea3bf4d5f41ae780f4773b7b4 (patch)
tree3aeb7e20eaba176536cb8d10ba531ac39674fc4a /configs/shared/emacs/.emacs.d/elpa/yasnippet-20180621.50
parent18b9930b8604134f087ca61fe94740b31f94327c (diff)
Remove Emacs spam
My inconsistent git history-keeping is coming to bite me here. At the
moment, I can only speculate about what went wrong here. The gist is
this: I unintentionally committed files that were supposed to be ignored

This commit removes those files which includes:

- auto-save-list
- elpa packages
- quelpa packages
- misc
Diffstat (limited to 'configs/shared/emacs/.emacs.d/elpa/yasnippet-20180621.50')
-rw-r--r--configs/shared/emacs/.emacs.d/elpa/yasnippet-20180621.50/yasnippet-autoloads.el56
-rw-r--r--configs/shared/emacs/.emacs.d/elpa/yasnippet-20180621.50/yasnippet-pkg.el2
-rw-r--r--configs/shared/emacs/.emacs.d/elpa/yasnippet-20180621.50/yasnippet.el5106
-rw-r--r--configs/shared/emacs/.emacs.d/elpa/yasnippet-20180621.50/yasnippet.elcbin216138 -> 0 bytes
4 files changed, 0 insertions, 5164 deletions
diff --git a/configs/shared/emacs/.emacs.d/elpa/yasnippet-20180621.50/yasnippet-autoloads.el b/configs/shared/emacs/.emacs.d/elpa/yasnippet-20180621.50/yasnippet-autoloads.el
deleted file mode 100644
index 301eb8d01cb8..000000000000
--- a/configs/shared/emacs/.emacs.d/elpa/yasnippet-20180621.50/yasnippet-autoloads.el
+++ /dev/null
@@ -1,56 +0,0 @@
-;;; yasnippet-autoloads.el --- automatically extracted autoloads
-;;
-;;; Code:
-(add-to-list 'load-path (directory-file-name (or (file-name-directory #$) (car load-path))))
-
-;;;### (autoloads nil "yasnippet" "yasnippet.el" (23450 31788 755921
-;;;;;;  640000))
-;;; Generated autoloads from yasnippet.el
-
-(autoload 'yas-minor-mode "yasnippet" "\
-Toggle YASnippet mode.
-
-When YASnippet mode is enabled, `yas-expand', normally bound to
-the TAB key, expands snippets of code depending on the major
-mode.
-
-With no argument, this command toggles the mode.
-positive prefix argument turns on the mode.
-Negative prefix argument turns off the mode.
-
-Key bindings:
-\\{yas-minor-mode-map}
-
-\(fn &optional ARG)" t nil)
-
-(defvar yas-global-mode nil "\
-Non-nil if Yas-Global mode is enabled.
-See the `yas-global-mode' command
-for a description of this minor mode.
-Setting this variable directly does not take effect;
-either customize it (see the info node `Easy Customization')
-or call the function `yas-global-mode'.")
-
-(custom-autoload 'yas-global-mode "yasnippet" nil)
-
-(autoload 'yas-global-mode "yasnippet" "\
-Toggle Yas minor mode in all buffers.
-With prefix ARG, enable Yas-Global mode if ARG is positive;
-otherwise, disable it.  If called from Lisp, enable the mode if
-ARG is omitted or nil.
-
-Yas minor mode is enabled in all buffers where
-`yas-minor-mode-on' would do it.
-See `yas-minor-mode' for more information on Yas minor mode.
-
-\(fn &optional ARG)" t nil)
-(autoload 'snippet-mode "yasnippet" "A mode for editing yasnippets" t nil)
-
-;;;***
-
-;; Local Variables:
-;; version-control: never
-;; no-byte-compile: t
-;; no-update-autoloads: t
-;; End:
-;;; yasnippet-autoloads.el ends here
diff --git a/configs/shared/emacs/.emacs.d/elpa/yasnippet-20180621.50/yasnippet-pkg.el b/configs/shared/emacs/.emacs.d/elpa/yasnippet-20180621.50/yasnippet-pkg.el
deleted file mode 100644
index 8207b332ef26..000000000000
--- a/configs/shared/emacs/.emacs.d/elpa/yasnippet-20180621.50/yasnippet-pkg.el
+++ /dev/null
@@ -1,2 +0,0 @@
-;;; -*- no-byte-compile: t -*-
-(define-package "yasnippet" "20180621.50" "Yet another snippet extension for Emacs." '((cl-lib "0.5")) :commit "1e713608682685d4a9b78519c84e3196e207c353" :keywords '("convenience" "emulation") :maintainer '("Noam Postavsky" . "npostavs@gmail.com") :url "http://github.com/joaotavora/yasnippet")
diff --git a/configs/shared/emacs/.emacs.d/elpa/yasnippet-20180621.50/yasnippet.el b/configs/shared/emacs/.emacs.d/elpa/yasnippet-20180621.50/yasnippet.el
deleted file mode 100644
index c5c05fa1523a..000000000000
--- a/configs/shared/emacs/.emacs.d/elpa/yasnippet-20180621.50/yasnippet.el
+++ /dev/null
@@ -1,5106 +0,0 @@
-;;; yasnippet.el --- Yet another snippet extension for Emacs.
-
-;; Copyright (C) 2008-2018 Free Software Foundation, Inc.
-;; Authors: pluskid <pluskid@gmail.com>,
-;;          João Távora <joaotavora@gmail.com>,
-;;          Noam Postavsky <npostavs@gmail.com>
-;; Maintainer: Noam Postavsky <npostavs@gmail.com>
-;; Version: 0.13.0
-;; Package-Version: 20180621.50
-;; X-URL: http://github.com/joaotavora/yasnippet
-;; Keywords: convenience, emulation
-;; URL: http://github.com/joaotavora/yasnippet
-;; Package-Requires: ((cl-lib "0.5"))
-;; EmacsWiki: YaSnippetMode
-
-;; 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:
-;;
-;;   Basic steps to setup:
-;;
-;;    (add-to-list 'load-path
-;;                 "~/path-to-yasnippet")
-;;    (require 'yasnippet)
-;;    (yas-global-mode 1)
-;;
-;;
-;;   Interesting variables are:
-;;
-;;       `yas-snippet-dirs'
-;;
-;;           The directory where user-created snippets are to be
-;;           stored.  Can also be a list of directories.  In that case,
-;;           when used for bulk (re)loading of snippets (at startup or
-;;           via `yas-reload-all'), directories appearing earlier in
-;;           the list override other dir's snippets.  Also, the first
-;;           directory is taken as the default for storing the user's
-;;           new snippets.
-;;
-;;           The deprecated `yas/root-directory' aliases this variable
-;;           for backward-compatibility.
-;;
-;;
-;;   Major commands are:
-;;
-;;       M-x yas-expand
-;;
-;;           Try to expand snippets before point.  In `yas-minor-mode',
-;;           this is normally bound to TAB, but you can customize it in
-;;           `yas-minor-mode-map'.
-;;
-;;       M-x yas-load-directory
-;;
-;;           Prompts you for a directory hierarchy of snippets to load.
-;;
-;;       M-x yas-activate-extra-mode
-;;
-;;           Prompts you for an extra mode to add snippets for in the
-;;           current buffer.
-;;
-;;       M-x yas-insert-snippet
-;;
-;;           Prompts you for possible snippet expansion if that is
-;;           possible according to buffer-local and snippet-local
-;;           expansion conditions.  With prefix argument, ignore these
-;;           conditions.
-;;
-;;       M-x yas-visit-snippet-file
-;;
-;;           Prompts you for possible snippet expansions like
-;;           `yas-insert-snippet', but instead of expanding it, takes
-;;           you directly to the snippet definition's file, if it
-;;           exists.
-;;
-;;       M-x yas-new-snippet
-;;
-;;           Lets you create a new snippet file in the correct
-;;           subdirectory of `yas-snippet-dirs', according to the
-;;           active major mode.
-;;
-;;       M-x yas-load-snippet-buffer
-;;
-;;           When editing a snippet, this loads the snippet.  This is
-;;           bound to "C-c C-c" while in the `snippet-mode' editing
-;;           mode.
-;;
-;;       M-x yas-tryout-snippet
-;;
-;;           When editing a snippet, this opens a new empty buffer,
-;;           sets it to the appropriate major mode and inserts the
-;;           snippet there, so you can see what it looks like.  This is
-;;           bound to "C-c C-t" while in `snippet-mode'.
-;;
-;;       M-x yas-describe-tables
-;;
-;;           Lists known snippets in a separate buffer.  User is
-;;           prompted as to whether only the currently active tables
-;;           are to be displayed, or all the tables for all major
-;;           modes.
-;;
-;;   If you have `dropdown-list' installed, you can optionally use it
-;;   as the preferred "prompting method", putting in your .emacs file,
-;;   for example:
-;;
-;;       (require 'dropdown-list)
-;;       (setq yas-prompt-functions '(yas-dropdown-prompt
-;;                                    yas-ido-prompt
-;;                                    yas-completing-prompt))
-;;
-;;   Also check out the customization group
-;;
-;;        M-x customize-group RET yasnippet RET
-;;
-;;   If you use the customization group to set variables
-;;   `yas-snippet-dirs' or `yas-global-mode', make sure the path to
-;;   "yasnippet.el" is present in the `load-path' *before* the
-;;   `custom-set-variables' is executed in your .emacs file.
-;;
-;;   For more information and detailed usage, refer to the project page:
-;;      http://github.com/joaotavora/yasnippet
-
-;;; Code:
-
-(require 'cl-lib)
-(declare-function cl-progv-after "cl-extra") ; Needed for 23.4.
-(require 'easymenu)
-(require 'help-mode)
-
-(defvar yas--editing-template)
-(defvar yas--guessed-modes)
-(defvar yas--indent-original-column)
-(defvar yas--scheduled-jit-loads)
-(defvar yas-keymap)
-(defvar yas-selected-text)
-(defvar yas-verbosity)
-(defvar yas--current-template)
-
-
-;;; User customizable variables
-
-(defgroup yasnippet nil
-  "Yet Another Snippet extension"
-  :prefix "yas-"
-  :group 'editing)
-
-(defconst yas--loaddir
-  (file-name-directory (or load-file-name buffer-file-name))
-  "Directory that yasnippet was loaded from.")
-
-(defconst yas-installed-snippets-dir (expand-file-name "snippets" yas--loaddir))
-(make-obsolete-variable 'yas-installed-snippets-dir "\
-Yasnippet no longer comes with installed snippets" "0.13")
-
-(defconst yas--default-user-snippets-dir
-  (expand-file-name "snippets" user-emacs-directory))
-
-(defcustom yas-snippet-dirs (list yas--default-user-snippets-dir)
-  "List of top-level snippet directories.
-
-Each element, a string or a symbol whose value is a string,
-designates a top-level directory where per-mode snippet
-directories can be found.
-
-Elements appearing earlier in the list override later elements'
-snippets.
-
-The first directory is taken as the default for storing snippet's
-created with `yas-new-snippet'. "
-  :type '(choice (directory :tag "Single directory")
-                 (repeat :tag "List of directories"
-                         (choice (directory) (variable))))
-  :set #'(lambda (symbol new)
-           (let ((old (and (boundp symbol)
-                           (symbol-value symbol))))
-             (set-default symbol new)
-             (unless (or (not (fboundp 'yas-reload-all))
-                         (equal old new))
-               (yas-reload-all)))))
-
-(defun yas-snippet-dirs ()
-  "Return variable `yas-snippet-dirs' as list of strings."
-  (cl-loop for e in (if (listp yas-snippet-dirs)
-                        yas-snippet-dirs
-                      (list yas-snippet-dirs))
-           collect
-           (cond ((stringp e) e)
-                 ((and (symbolp e)
-                       (boundp e)
-                       (stringp (symbol-value e)))
-                  (symbol-value e))
-                 (t
-                  (error "[yas] invalid element %s in `yas-snippet-dirs'" e)))))
-
-(defcustom yas-new-snippet-default "\
-# -*- mode: snippet -*-
-# name: $1
-# key: ${2:${1:$(yas--key-from-desc yas-text)}}
-# --
-$0`(yas-escape-text yas-selected-text)`"
-  "Default snippet to use when creating a new snippet.
-If nil, don't use any snippet."
-  :type 'string)
-
-(defcustom yas-prompt-functions '(yas-dropdown-prompt
-                                  yas-completing-prompt
-                                  yas-maybe-ido-prompt
-                                  yas-no-prompt)
-  "Functions to prompt for keys, templates, etc interactively.
-
-These functions are called with the following arguments:
-
-- PROMPT: A string to prompt the user
-
-- CHOICES: a list of strings or objects.
-
-- optional DISPLAY-FN : A function that, when applied to each of
-the objects in CHOICES will return a string.
-
-The return value of any function you put here should be one of
-the objects in CHOICES, properly formatted with DISPLAY-FN (if
-that is passed).
-
-- To signal that your particular style of prompting is
-unavailable at the moment, you can also have the function return
-nil.
-
-- To signal that the user quit the prompting process, you can
-signal `quit' with
-
-    (signal \\='quit \"user quit!\")"
-  :type '(repeat function))
-
-(defcustom yas-indent-line 'auto
-  "Controls indenting applied to a recent snippet expansion.
-
-The following values are possible:
-
-- `fixed' Indent the snippet to the current column;
-
-- `auto' Indent each line of the snippet with `indent-according-to-mode'
-
-Every other value means don't apply any snippet-side indentation
-after expansion (the manual per-line \"$>\" indentation still
-applies)."
-  :type '(choice (const :tag "Nothing"  nothing)
-                 (const :tag "Fixed"    fixed)
-                 (const :tag "Auto"     auto)))
-
-(defcustom yas-also-auto-indent-first-line nil
-  "Non-nil means also auto indent first line according to mode.
-
-Naturally this is only valid when `yas-indent-line' is `auto'."
-  :type 'boolean)
-
-(defcustom yas-also-indent-empty-lines nil
-  "Non-nil means also indent empty lines according to mode."
-  :type 'boolean)
-
-(defcustom yas-snippet-revival t
-  "Non-nil means re-activate snippet fields after undo/redo."
-  :type 'boolean)
-
-(defcustom yas-triggers-in-field nil
-  "If non-nil, allow stacked expansions (snippets inside snippets).
-
-Otherwise `yas-next-field-or-maybe-expand' just moves on to the
-next field"
-  :type 'boolean)
-
-(defcustom yas-fallback-behavior 'return-nil
-  "This option is obsolete.
-Now that the conditional keybinding `yas-maybe-expand' is
-available, there's no more need for it."
-  :type '(choice (const :tag "Call previous command"  call-other-command)
-                 (const :tag "Do nothing"             return-nil)))
-
-(make-obsolete-variable
- 'yas-fallback-behavior
- "For `call-other-command' behavior bind to the conditional
-command value `yas-maybe-expand', for `return-nil' behavior bind
-directly to `yas-expand'."
- "0.12")
-
-(defcustom yas-choose-keys-first nil
-  "If non-nil, prompt for snippet key first, then for template.
-
-Otherwise prompts for all possible snippet names.
-
-This affects `yas-insert-snippet' and `yas-visit-snippet-file'."
-  :type 'boolean)
-
-(defcustom yas-choose-tables-first nil
-  "If non-nil, and multiple eligible snippet tables, prompts user for tables first.
-
-Otherwise, user chooses between the merging together of all
-eligible tables.
-
-This affects `yas-insert-snippet', `yas-visit-snippet-file'"
-  :type 'boolean)
-
-(defcustom yas-use-menu 'abbreviate
-  "Display a YASnippet menu in the menu bar.
-
-When non-nil, submenus for each snippet table will be listed
-under the menu \"Yasnippet\".
-
-- If set to `abbreviate', only the current major-mode
-menu and the modes set in `yas--extra-modes' are listed.
-
-- If set to `full', every submenu is listed
-
-- If set to nil, hide the menu.
-
-Any other non-nil value, every submenu is listed."
-  :type '(choice (const :tag "Full"  full)
-                 (const :tag "Abbreviate" abbreviate)
-                 (const :tag "No menu" nil)))
-
-(defcustom yas-trigger-symbol (or (and (eq window-system 'mac)
-                                       (ignore-errors
-                                         (char-to-string ?\x21E5))) ;; little ->| sign
-                                  " =>")
-  "The text that will be used in menu to represent the trigger."
-  :type 'string)
-
-(defcustom yas-wrap-around-region nil
-  "What to insert for snippet's $0 field.
-
-If set to a character, insert contents of corresponding register.
-If non-nil insert region contents.  This can be overridden on a
-per-snippet basis.  A value of `cua' is considered equivalent to
-`?0' for backwards compatibility."
-  :type '(choice (character :tag "Insert from register")
-                 (const t :tag "Insert region contents")
-                 (const nil :tag "Don't insert anything")
-                 (const cua))) ; backwards compat
-
-(defcustom yas-good-grace t
-  "If non-nil, don't raise errors in elisp evaluation.
-
-This affects both the inline elisp in snippets and the hook
-variables such as `yas-after-exit-snippet-hook'.
-
-If this variable's value is `inline', an error string \"[yas]
-error\" is returned instead of raising the error.  If this
-variable's value is `hooks', a message is output to according to
-`yas-verbosity-level'.  If this variable's value is t, both are
-active."
-  :type 'boolean)
-
-(defcustom yas-visit-from-menu nil
-  "If non-nil visit snippets's files from menu, instead of expanding them.
-
-This can only work when snippets are loaded from files."
-  :type 'boolean)
-
-(defcustom yas-expand-only-for-last-commands nil
-  "List of `last-command' values to restrict tab-triggering to, or nil.
-
-Leave this set at nil (the default) to be able to trigger an
-expansion simply by placing the cursor after a valid tab trigger,
-using whichever commands.
-
-Optionally, set this to something like (self-insert-command) if
-you to wish restrict expansion to only happen when the last
-letter of the snippet tab trigger was typed immediately before
-the trigger key itself."
-  :type '(repeat function))
-
-(defcustom yas-alias-to-yas/prefix-p t
-  "If non-nil make aliases for the old style yas/ prefixed symbols.
-It must be set to nil before loading yasnippet to take effect."
-  :type 'boolean
-  :group 'yasnippet)
-
-;; Only two faces, and one of them shouldn't even be used...
-;;
-(defface yas-field-highlight-face
-  '((t (:inherit 'region)))
-  "The face used to highlight the currently active field of a snippet")
-
-(defface yas--field-debug-face
-  '()
-  "The face used for debugging some overlays normally hidden")
-
-
-;;; User-visible variables
-
-(defconst yas-maybe-skip-and-clear-field
-  '(menu-item "" yas-skip-and-clear-field
-              :filter yas--maybe-clear-field-filter)
-  "A conditional key definition.
-This can be used as a key definition in keymaps to bind a key to
-`yas-skip-and-clear-field' only when at the beginning of an
-unmodified snippey field.")
-
-(defvar yas-keymap  (let ((map (make-sparse-keymap)))
-                      (define-key map [(tab)]       'yas-next-field-or-maybe-expand)
-                      (define-key map (kbd "TAB")   'yas-next-field-or-maybe-expand)
-                      (define-key map [(shift tab)] 'yas-prev-field)
-                      (define-key map [backtab]     'yas-prev-field)
-                      (define-key map (kbd "C-g")   'yas-abort-snippet)
-                      (define-key map (kbd "C-d")   yas-maybe-skip-and-clear-field)
-                      map)
-  "The active keymap while a snippet expansion is in progress.")
-
-(defvar yas-key-syntaxes (list #'yas-try-key-from-whitespace
-                               "w_.()" "w_." "w_" "w")
-  "Syntaxes and functions to help look for trigger keys before point.
-
-Each element in this list specifies how to skip buffer positions
-backwards and look for the start of a trigger key.
-
-Each element can be either a string or a function receiving the
-original point as an argument. A string element is simply passed
-to `skip-syntax-backward' whereas a function element is called
-with no arguments and should also place point before the original
-position.
-
-The string between the resulting buffer position and the original
-point is matched against the trigger keys in the active snippet
-tables.
-
-If no expandable snippets are found, the next element is the list
-is tried, unless a function element returned the symbol `again',
-in which case it is called again from the previous position and
-may once more reposition point.
-
-For example, if `yas-key-syntaxes' has the value (\"w\" \"w_\"),
-trigger keys composed exclusively of \"word\"-syntax characters
-are looked for first. Failing that, longer keys composed of
-\"word\" or \"symbol\" syntax are looked for. Therefore,
-triggering after
-
-foo-bar
-
-will, according to the \"w\" element first try \"barbaz\". If
-that isn't a trigger key, \"foo-barbaz\" is tried, respecting the
-second \"w_\" element. Notice that even if \"baz\" is a trigger
-key for an active snippet, it won't be expanded, unless a
-function is added to `yas-key-syntaxes' that eventually places
-point between \"bar\" and \"baz\".
-
-See also Info node `(elisp) Syntax Descriptors'.")
-
-(defvar yas-after-exit-snippet-hook
-  '()
-  "Hooks to run after a snippet exited.
-
-The hooks will be run in an environment where some variables bound to
-proper values:
-
-`yas-snippet-beg' : The beginning of the region of the snippet.
-
-`yas-snippet-end' : Similar to beg.
-
-Attention: These hooks are not run when exiting nested/stacked snippet expansion!")
-
-(defvar yas-before-expand-snippet-hook
-  '()
-  "Hooks to run just before expanding a snippet.")
-
-(defconst yas-not-string-or-comment-condition
-  '(if (and (let ((ppss (syntax-ppss)))
-              (or (nth 3 ppss) (nth 4 ppss)))
-            (memq this-command '(yas-expand yas-expand-from-trigger-key
-                                            yas-expand-from-keymap)))
-       '(require-snippet-condition . force-in-comment)
-     t)
-  "Disables snippet expansion in strings and comments.
-To use, set `yas-buffer-local-condition' to this value.")
-
-(defcustom yas-buffer-local-condition t
-  "Snippet expanding condition.
-
-This variable is a Lisp form which is evaluated every time a
-snippet expansion is attempted:
-
-    * If it evaluates to nil, no snippets can be expanded.
-
-    * If it evaluates to the a cons (require-snippet-condition
-      . REQUIREMENT)
-
-       * Snippets bearing no \"# condition:\" directive are not
-         considered
-
-       * Snippets bearing conditions that evaluate to nil (or
-         produce an error) won't be considered.
-
-       * If the snippet has a condition that evaluates to non-nil
-         RESULT:
-
-          * If REQUIREMENT is t, the snippet is considered
-
-          * If REQUIREMENT is `eq' RESULT, the snippet is
-            considered
-
-          * Otherwise, the snippet is not considered.
-
-    * If it evaluates to the symbol `always', all snippets are
-      considered for expansion, regardless of any conditions.
-
-    * If it evaluates to t or some other non-nil value
-
-       * Snippet bearing no conditions, or conditions that
-         evaluate to non-nil, are considered for expansion.
-
-       * Otherwise, the snippet is not considered.
-
-Here's an example preventing snippets from being expanded from
-inside comments, in `python-mode' only, with the exception of
-snippets returning the symbol `force-in-comment' in their
-conditions.
-
- (add-hook \\='python-mode-hook
-           (lambda ()
-              (setq yas-buffer-local-condition
-                    \\='(if (python-syntax-comment-or-string-p)
-                         \\='(require-snippet-condition . force-in-comment)
-                       t))))"
-  :type
-  `(choice
-    (const :tag "Disable snippet expansion inside strings and comments"
-           ,yas-not-string-or-comment-condition)
-    (const :tag "Expand all snippets regardless of conditions" always)
-    (const :tag "Expand snippets unless their condition is nil" t)
-    (const :tag "Disable all snippet expansion" nil)
-    sexp))
-
-(defcustom yas-overlay-priority 100
-  "Priority to use for yasnippets overlays.
-This is useful to control whether snippet navigation bindings
-override bindings from other packages (e.g., `company-mode')."
-  :type 'integer)
-
-
-;;; Internal variables
-
-(defconst yas--version "0.13.0")
-
-(defvar yas--menu-table (make-hash-table)
-  "A hash table of MAJOR-MODE symbols to menu keymaps.")
-
-(defvar yas--escaped-characters
-  '(?\\ ?` ?\" ?' ?$ ?} ?{ ?\( ?\))
-  "List of characters which *might* need to be escaped.")
-
-(defconst yas--field-regexp
-  "${\\([0-9]+:\\)?\\([^}]*\\)}"
-  "A regexp to *almost* recognize a field.")
-
-(defconst yas--multi-dollar-lisp-expression-regexp
-  "$+[ \t\n]*\\(([^)]*)\\)"
-  "A regexp to *almost* recognize a \"$(...)\" expression.")
-
-(defconst yas--backquote-lisp-expression-regexp
-  "`\\([^`]*\\)`"
-  "A regexp to recognize a \"\\=`lisp-expression\\=`\" expression." )
-
-(defconst yas--transform-mirror-regexp
-  "${\\(?:\\([0-9]+\\):\\)?$\\([ \t\n]*([^}]*\\)"
-  "A regexp to *almost* recognize a mirror with a transform.")
-
-(defconst yas--simple-mirror-regexp
-  "$\\([0-9]+\\)"
-  "A regexp to recognize a simple mirror.")
-
-(defvar yas--snippet-id-seed 0
-  "Contains the next id for a snippet.")
-
-(defvar yas--original-auto-fill-function nil
-  "The original value of `auto-fill-function'.")
-(make-variable-buffer-local 'yas--original-auto-fill-function)
-
-(defvar yas--watch-auto-fill-backtrace nil)
-
-(defun yas--watch-auto-fill (sym newval op _where)
-  (when (and (or (and (eq sym 'yas--original-auto-fill-function)
-                      (null newval)
-                      (eq auto-fill-function 'yas--auto-fill))
-                 (and (eq sym 'auto-fill-function)
-                      (eq newval 'yas--auto-fill)
-                      (null yas--original-auto-fill-function)))
-             (null yas--watch-auto-fill-backtrace)
-             (fboundp 'backtrace-frames) ; Suppress compiler warning.
-             ;; If we're about to change `auto-fill-function' too,
-             ;; it's okay (probably).
-             (not (and (eq op 'makunbound)
-                       (not (eq (default-value 'auto-fill-function) 'yas--auto-fill))
-                       (cl-member 'kill-all-local-variables
-                                  (backtrace-frames 'yas--watch-auto-fill)
-                                  :key (lambda (frame) (nth 1 frame))))))
-    (setq yas--watch-auto-fill-backtrace
-          (backtrace-frames 'yas--watch-auto-fill))))
-
-;; Try to get more info on #873/919 (this only works for Emacs 26+).
-(when (fboundp 'add-variable-watcher)
-  (add-variable-watcher 'yas--original-auto-fill-function
-                        #'yas--watch-auto-fill)
-  (add-variable-watcher 'auto-fill-function
-                        #'yas--watch-auto-fill))
-
-(defun yas--snippet-next-id ()
-  (let ((id yas--snippet-id-seed))
-    (cl-incf yas--snippet-id-seed)
-    id))
-
-
-;;; Minor mode stuff
-
-(defvar yas--minor-mode-menu nil
-  "Holds the YASnippet menu.")
-
-(defvar yas--condition-cache-timestamp nil)
-
-(defun yas--maybe-expand-key-filter (cmd)
-  (when (let ((yas--condition-cache-timestamp (current-time)))
-          (yas--templates-for-key-at-point))
-    cmd))
-
-(defconst yas-maybe-expand
-  '(menu-item "" yas-expand :filter yas--maybe-expand-key-filter)
-  "A conditional key definition.
-This can be used as a key definition in keymaps to bind a key to
-`yas-expand' only when there is a snippet available to be
-expanded.")
-
-(defvar yas-minor-mode-map
-  (let ((map (make-sparse-keymap)))
-    (define-key map [(tab)]     yas-maybe-expand)
-    (define-key map (kbd "TAB") yas-maybe-expand)
-    (define-key map "\C-c&\C-s" 'yas-insert-snippet)
-    (define-key map "\C-c&\C-n" 'yas-new-snippet)
-    (define-key map "\C-c&\C-v" 'yas-visit-snippet-file)
-    map)
-  "The keymap used when `yas-minor-mode' is active.")
-
-(easy-menu-define yas--minor-mode-menu
-      yas-minor-mode-map
-      "Menu used when `yas-minor-mode' is active."
-  '("YASnippet" :visible yas-use-menu
-    "----"
-    ["Expand trigger" yas-expand
-     :help "Possibly expand tab trigger before point"]
-    ["Insert at point..." yas-insert-snippet
-     :help "Prompt for an expandable snippet and expand it at point"]
-    ["New snippet..." yas-new-snippet
-     :help "Create a new snippet in an appropriate directory"]
-    ["Visit snippet file..." yas-visit-snippet-file
-     :help "Prompt for an expandable snippet and find its file"]
-    "----"
-    ("Snippet menu behaviour"
-     ["Visit snippets" (setq yas-visit-from-menu t)
-      :help "Visit snippets from the menu"
-      :active t :style radio   :selected yas-visit-from-menu]
-     ["Expand snippets" (setq yas-visit-from-menu nil)
-      :help "Expand snippets from the menu"
-      :active t :style radio :selected (not yas-visit-from-menu)]
-     "----"
-     ["Show all known modes" (setq yas-use-menu 'full)
-      :help "Show one snippet submenu for each loaded table"
-      :active t :style radio   :selected (eq yas-use-menu 'full)]
-     ["Abbreviate according to current mode" (setq yas-use-menu 'abbreviate)
-      :help "Show only snippet submenus for the current active modes"
-      :active t :style radio   :selected (eq yas-use-menu 'abbreviate)])
-    ("Indenting"
-     ["Auto" (setq yas-indent-line 'auto)
-      :help "Indent each line of the snippet with `indent-according-to-mode'"
-      :active t :style radio   :selected (eq yas-indent-line 'auto)]
-     ["Fixed" (setq yas-indent-line 'fixed)
-      :help "Indent the snippet to the current column"
-      :active t :style radio   :selected (eq yas-indent-line 'fixed)]
-     ["None" (setq yas-indent-line 'none)
-      :help "Don't apply any particular snippet indentation after expansion"
-      :active t :style radio   :selected (not (member yas-indent-line '(fixed auto)))]
-     "----"
-     ["Also auto indent first line" (setq yas-also-auto-indent-first-line
-                                          (not yas-also-auto-indent-first-line))
-      :help "When auto-indenting also, auto indent the first line menu"
-      :active (eq yas-indent-line 'auto)
-      :style toggle :selected yas-also-auto-indent-first-line]
-     )
-    ("Prompting method"
-     ["System X-widget" (setq yas-prompt-functions
-                              (cons #'yas-x-prompt
-                                    (remove #'yas-x-prompt
-                                            yas-prompt-functions)))
-      :help "Use your windowing system's (gtk, mac, windows, etc...) default menu"
-      :active t :style radio   :selected (eq (car yas-prompt-functions)
-                                             #'yas-x-prompt)]
-     ["Dropdown-list" (setq yas-prompt-functions
-                            (cons #'yas-dropdown-prompt
-                                  (remove #'yas-dropdown-prompt
-                                          yas-prompt-functions)))
-      :help "Use a special dropdown list"
-      :active t :style radio   :selected (eq (car yas-prompt-functions)
-                                             #'yas-dropdown-prompt)]
-     ["Ido" (setq yas-prompt-functions
-                  (cons #'yas-ido-prompt
-                        (remove #'yas-ido-prompt
-                                yas-prompt-functions)))
-      :help "Use an ido-style minibuffer prompt"
-      :active t :style radio   :selected (eq (car yas-prompt-functions)
-                                             #'yas-ido-prompt)]
-     ["Completing read" (setq yas-prompt-functions
-                              (cons #'yas-completing-prompt
-                                    (remove #'yas-completing-prompt
-                                            yas-prompt-functions)))
-      :help "Use a normal minibuffer prompt"
-      :active t :style radio   :selected (eq (car yas-prompt-functions)
-                                             #'yas-completing-prompt)]
-     )
-    ("Misc"
-     ["Wrap region in exit marker"
-      (setq yas-wrap-around-region
-            (not yas-wrap-around-region))
-      :help "If non-nil automatically wrap the selected text in the $0 snippet exit"
-      :style toggle :selected yas-wrap-around-region]
-     ["Allow stacked expansions "
-      (setq yas-triggers-in-field
-            (not yas-triggers-in-field))
-      :help "If non-nil allow snippets to be triggered inside other snippet fields"
-      :style toggle :selected yas-triggers-in-field]
-     ["Revive snippets on undo "
-      (setq yas-snippet-revival
-            (not yas-snippet-revival))
-      :help "If non-nil allow snippets to become active again after undo"
-      :style toggle :selected yas-snippet-revival]
-     ["Good grace "
-      (setq yas-good-grace
-            (not yas-good-grace))
-      :help "If non-nil don't raise errors in bad embedded elisp in snippets"
-      :style toggle :selected yas-good-grace]
-     )
-    "----"
-    ["Load snippets..."  yas-load-directory
-     :help "Load snippets from a specific directory"]
-    ["Reload everything" yas-reload-all
-     :help "Cleanup stuff, reload snippets, rebuild menus"]
-    ["About"            yas-about
-     :help "Display some information about YASnippet"]))
-
-(defvar yas--extra-modes nil
-  "An internal list of modes for which to also lookup snippets.
-
-This variable probably makes more sense as buffer-local, so
-ensure your use `make-local-variable' when you set it.")
-(define-obsolete-variable-alias 'yas-extra-modes 'yas--extra-modes "0.9.1")
-
-(defvar yas--tables (make-hash-table)
-  "A hash table of mode symbols to `yas--table' objects.")
-
-(defvar yas--parents (make-hash-table)
-  "A hash table of mode symbols do lists of direct parent mode symbols.
-
-This list is populated when reading the \".yas-parents\" files
-found when traversing snippet directories with
-`yas-load-directory'.
-
-There might be additional parenting information stored in the
-`derived-mode-parent' property of some mode symbols, but that is
-not recorded here.")
-
-(defvar yas--direct-keymaps (list)
-  "Keymap alist supporting direct snippet keybindings.
-
-This variable is placed in `emulation-mode-map-alists'.
-
-Its elements looks like (TABLE-NAME . KEYMAP).  They're
-instantiated on `yas-reload-all' but KEYMAP is added to only when
-loading snippets.  `yas--direct-TABLE-NAME' is then a variable
-set buffer-locally when entering `yas-minor-mode'.  KEYMAP binds
-all defined direct keybindings to `yas-maybe-expand-from-keymap'
-which decides on the snippet to expand.")
-
-(defun yas-direct-keymaps-reload ()
-  "Force reload the direct keybinding for active snippet tables."
-  (interactive)
-  (setq yas--direct-keymaps nil)
-  (maphash #'(lambda (name table)
-               (push (cons (intern (format "yas--direct-%s" name))
-                           (yas--table-direct-keymap table))
-                     yas--direct-keymaps))
-           yas--tables))
-
-(defun yas--modes-to-activate (&optional mode)
-  "Compute list of mode symbols that are active for `yas-expand' and friends."
-  (defvar yas--dfs)        ;We rely on dynbind.  We could use `letrec' instead!
-  (let* ((explored (if mode (list mode) ; Building up list in reverse.
-                     (cons major-mode (reverse yas--extra-modes))))
-         (yas--dfs
-          (lambda (mode)
-            (cl-loop for neighbour
-                     in (cl-list* (get mode 'derived-mode-parent)
-                                  ;; NOTE: `fboundp' check is redundant
-                                  ;; since Emacs 24.4.
-                                  (and (fboundp mode) (symbol-function mode))
-                                  (gethash mode yas--parents))
-                     when (and neighbour
-                               (not (memq neighbour explored))
-                               (symbolp neighbour))
-                     do (push neighbour explored)
-                     (funcall yas--dfs neighbour)))))
-    (mapc yas--dfs explored)
-    (nreverse explored)))
-
-(defvar yas-minor-mode-hook nil
-  "Hook run when `yas-minor-mode' is turned on.")
-
-(defun yas--auto-fill-wrapper ()
-  (when (and auto-fill-function
-             (not (eq auto-fill-function #'yas--auto-fill)))
-    (setq yas--original-auto-fill-function auto-fill-function)
-    (setq auto-fill-function #'yas--auto-fill)))
-
-;;;###autoload
-(define-minor-mode yas-minor-mode
-  "Toggle YASnippet mode.
-
-When YASnippet mode is enabled, `yas-expand', normally bound to
-the TAB key, expands snippets of code depending on the major
-mode.
-
-With no argument, this command toggles the mode.
-positive prefix argument turns on the mode.
-Negative prefix argument turns off the mode.
-
-Key bindings:
-\\{yas-minor-mode-map}"
-  :lighter " yas" ;; The indicator for the mode line.
-  (cond ((and yas-minor-mode (featurep 'yasnippet))
-         ;; Install the direct keymaps in `emulation-mode-map-alists'
-         ;; (we use `add-hook' even though it's not technically a hook,
-         ;; but it works). Then define variables named after modes to
-         ;; index `yas--direct-keymaps'.
-         ;;
-         ;; Also install the post-command-hook.
-         ;;
-         (cl-pushnew 'yas--direct-keymaps emulation-mode-map-alists)
-         (add-hook 'post-command-hook #'yas--post-command-handler nil t)
-         ;; Set the `yas--direct-%s' vars for direct keymap expansion
-         ;;
-         (dolist (mode (yas--modes-to-activate))
-           (let ((name (intern (format "yas--direct-%s" mode))))
-             (set-default name nil)
-             (set (make-local-variable name) t)))
-         ;; Perform JIT loads
-         (yas--load-pending-jits)
-         ;; Install auto-fill handler.
-         (yas--auto-fill-wrapper)       ; Now...
-         (add-hook 'auto-fill-mode-hook #'yas--auto-fill-wrapper)) ; or later.
-        (t
-         ;; Uninstall the direct keymaps, post-command hook, and
-         ;; auto-fill handler.
-         (remove-hook 'post-command-hook #'yas--post-command-handler t)
-         (remove-hook 'auto-fill-mode-hook #'yas--auto-fill-wrapper)
-         (when (local-variable-p 'yas--original-auto-fill-function)
-           (setq auto-fill-function yas--original-auto-fill-function))
-         (setq emulation-mode-map-alists
-               (remove 'yas--direct-keymaps emulation-mode-map-alists)))))
-
-(defun yas-activate-extra-mode (mode)
-  "Activates the snippets for the given `mode' in the buffer.
-
-The function can be called in the hook of a minor mode to
-activate snippets associated with that mode."
-  (interactive
-   (let (modes
-         symbol)
-     (maphash (lambda (k _)
-                (setq modes (cons (list k) modes)))
-              yas--parents)
-     (setq symbol (completing-read
-                   "Activate mode: " modes nil t))
-     (list
-      (when (not (string= "" symbol))
-        (intern symbol)))))
-  (when mode
-    (add-to-list (make-local-variable 'yas--extra-modes) mode)
-    (yas--load-pending-jits)))
-
-(defun yas-deactivate-extra-mode (mode)
-  "Deactivates the snippets for the given `mode' in the buffer."
-  (interactive
-   (list (intern
-          (completing-read
-           "Deactivate mode: " (mapcar #'list yas--extra-modes) nil t))))
-  (set (make-local-variable 'yas--extra-modes)
-       (remove mode
-               yas--extra-modes)))
-
-(define-obsolete-variable-alias 'yas-dont-activate
-  'yas-dont-activate-functions "0.9.2")
-(defvar yas-dont-activate-functions (list #'minibufferp)
-  "Special hook to control which buffers `yas-global-mode' affects.
-Functions are called with no argument, and should return non-nil to prevent
-`yas-global-mode' from enabling yasnippet in this buffer.
-
-In Emacsen < 24, this variable is buffer-local.  Because
-`yas-minor-mode-on' is called by `yas-global-mode' after
-executing the buffer's major mode hook, setting this variable
-there is an effective way to define exceptions to the \"global\"
-activation behaviour.
-
-In Emacsen >= 24, only the global value is used.  To define
-per-mode exceptions to the \"global\" activation behaviour, call
-`yas-minor-mode' with a negative argument directily in the major
-mode's hook.")
-(unless (> emacs-major-version 23)
-  (with-no-warnings
-    (make-variable-buffer-local 'yas-dont-activate)))
-
-
-(defun yas-minor-mode-on ()
-  "Turn on YASnippet minor mode.
-
-Honour `yas-dont-activate-functions', which see."
-  (interactive)
-  (unless (or
-           ;; The old behavior used for Emacs<24 was to set
-           ;; `yas-dont-activate-functions' to t buffer-locally.
-           (not (or (listp yas-dont-activate-functions)
-                    (functionp yas-dont-activate-functions)))
-           (run-hook-with-args-until-success 'yas-dont-activate-functions))
-    (yas-minor-mode 1)))
-
-;;;###autoload
-(define-globalized-minor-mode yas-global-mode yas-minor-mode yas-minor-mode-on)
-
-(defun yas--global-mode-reload-with-jit-maybe ()
-  "Run `yas-reload-all' when `yas-global-mode' is on."
-  (when yas-global-mode (yas-reload-all)))
-
-(add-hook 'yas-global-mode-hook #'yas--global-mode-reload-with-jit-maybe)
-
-
-;;; Major mode stuff
-
-(defvar yas--font-lock-keywords
-  (append '(("^#.*$" . font-lock-comment-face))
-          (with-temp-buffer
-            (let ((prog-mode-hook nil)
-                  (emacs-lisp-mode-hook nil))
-              (ignore-errors (emacs-lisp-mode)))
-            (font-lock-set-defaults)
-            (if (eq t (car-safe font-lock-keywords))
-                ;; They're "compiled", so extract the source.
-                (cadr font-lock-keywords)
-              font-lock-keywords))
-          '(("\\$\\([0-9]+\\)"
-             (0 font-lock-keyword-face)
-             (1 font-lock-string-face t))
-            ("\\${\\([0-9]+\\):?"
-             (0 font-lock-keyword-face)
-             (1 font-lock-warning-face t))
-            ("\\(\\$(\\)" 1 font-lock-preprocessor-face)
-            ("}"
-             (0 font-lock-keyword-face)))))
-
-(defvar snippet-mode-map
-  (let ((map (make-sparse-keymap)))
-    (easy-menu-define nil
-      map
-      "Menu used when snippet-mode is active."
-      (cons "Snippet"
-            (mapcar #'(lambda (ent)
-                        (when (nth 2 ent)
-                          (define-key map (nth 2 ent) (nth 1 ent)))
-                        (vector (nth 0 ent) (nth 1 ent) t))
-                    '(("Load this snippet" yas-load-snippet-buffer "\C-c\C-l")
-                      ("Load and quit window" yas-load-snippet-buffer-and-close "\C-c\C-c")
-                      ("Try out this snippet" yas-tryout-snippet "\C-c\C-t")))))
-    map)
-  "The keymap used when `snippet-mode' is active.")
-
-
-
-;;;###autoload(autoload 'snippet-mode "yasnippet" "A mode for editing yasnippets" t nil)
-(eval-and-compile
-  (if (fboundp 'prog-mode)
-      ;; `prog-mode' is new in 24.1.
-      (define-derived-mode snippet-mode prog-mode "Snippet"
-        "A mode for editing yasnippets"
-        (setq font-lock-defaults '(yas--font-lock-keywords))
-        (set (make-local-variable 'require-final-newline) nil)
-        (set (make-local-variable 'comment-start) "#")
-        (set (make-local-variable 'comment-start-skip) "#+[\t ]*")
-        (add-hook 'after-save-hook #'yas-maybe-load-snippet-buffer nil t))
-    (define-derived-mode snippet-mode fundamental-mode "Snippet"
-      "A mode for editing yasnippets"
-      (setq font-lock-defaults '(yas--font-lock-keywords))
-      (set (make-local-variable 'require-final-newline) nil)
-      (set (make-local-variable 'comment-start) "#")
-      (set (make-local-variable 'comment-start-skip) "#+[\t ]*")
-      (add-hook 'after-save-hook #'yas-maybe-load-snippet-buffer nil t))))
-
-(defun yas-snippet-mode-buffer-p ()
-  "Return non-nil if current buffer should be in `snippet-mode'.
-Meaning it's visiting a file under one of the mode directories in
-`yas-snippet-dirs'."
-  (when buffer-file-name
-    (cl-member buffer-file-name (yas-snippet-dirs)
-               :test #'file-in-directory-p)))
-
-;; We're abusing `magic-fallback-mode-alist' here because
-;; `auto-mode-alist' doesn't support function matchers.
-(add-to-list 'magic-fallback-mode-alist
-             `(yas-snippet-mode-buffer-p . snippet-mode))
-
-
-;;; Internal structs for template management
-
-(cl-defstruct (yas--template
-               (:constructor yas--make-template)
-               ;; Handles `yas-define-snippets' format, plus the
-               ;; initial TABLE argument.
-               (:constructor
-                yas--define-snippets-2
-                (table
-                 key content
-                 &optional xname condition group
-                 expand-env load-file xkeybinding xuuid save-file
-                 &aux
-                 (name (or xname
-                           ;; A little redundant: we always get a name
-                           ;; from `yas--parse-template' except when
-                           ;; there isn't a file.
-                           (and load-file (file-name-nondirectory load-file))
-                           (and save-file (file-name-nondirectory save-file))
-                           key))
-                 (keybinding (yas--read-keybinding xkeybinding))
-                 (uuid (or xuuid name))
-                 (old (gethash uuid (yas--table-uuidhash table)))
-                 (menu-binding-pair
-                  (and old (yas--template-menu-binding-pair old)))
-                 (perm-group
-                  (and old (yas--template-perm-group old))))))
-  "A template for a snippet."
-  key
-  content
-  name
-  condition
-  expand-env
-  load-file
-  save-file
-  keybinding
-  uuid
-  menu-binding-pair
-  group      ;; as dictated by the #group: directive or .yas-make-groups
-  perm-group ;; as dictated by `yas-define-menu'
-  table
-  )
-
-(cl-defstruct (yas--table (:constructor yas--make-snippet-table (name)))
-  "A table to store snippets for a particular mode.
-
-Has the following fields:
-
-`yas--table-name'
-
-  A symbol name normally corresponding to a major mode, but can
-  also be a pseudo major-mode to be used in
-  `yas-activate-extra-mode', for example.
-
-`yas--table-hash'
-
-  A hash table (KEY . NAMEHASH), known as the \"keyhash\". KEY is
-  a string or a vector, where the former is the snippet's trigger
-  and the latter means it's a direct keybinding. NAMEHASH is yet
-  another hash of (NAME . TEMPLATE) where NAME is the snippet's
-  name and TEMPLATE is a `yas--template' object.
-
-`yas--table-direct-keymap'
-
-  A keymap for the snippets in this table that have direct
-  keybindings. This is kept in sync with the keyhash, i.e., all
-  the elements of the keyhash that are vectors appear here as
-  bindings to `yas-maybe-expand-from-keymap'.
-
-`yas--table-uuidhash'
-
-  A hash table mapping snippets uuid's to the same `yas--template'
-  objects. A snippet uuid defaults to the snippet's name."
-  name
-  (hash (make-hash-table :test 'equal))
-  (uuidhash (make-hash-table :test 'equal))
-  (parents nil)
-  (direct-keymap (make-sparse-keymap)))
-
-(defun yas--get-template-by-uuid (mode uuid)
-  "Find the snippet template in MODE by its UUID."
-  (let* ((table (gethash mode yas--tables mode)))
-    (when table
-      (gethash uuid (yas--table-uuidhash table)))))
-
-;; Apropos storing/updating in TABLE, this works in two steps:
-;;
-;; 1. `yas--remove-template-by-uuid' removes any
-;;    keyhash-namehash-template mappings from TABLE, grabbing the
-;;    snippet by its uuid. Also removes mappings from TABLE's
-;;    `yas--table-direct-keymap' (FIXME: and should probably take care
-;;    of potentially stale menu bindings right?.)
-;;
-;; 2. `yas--add-template' adds this all over again.
-;;
-;;    Create a new or add to an existing keyhash-namehash mapping.
-;;
-;;  For reference on understanding this, consider three snippet
-;;  definitions:
-;;
-;;  A:   # name: The Foo
-;;       # key: foo
-;;       # binding: C-c M-l
-;;
-;;  B:   # name: Mrs Foo
-;;       # key: foo
-;;
-;;  C:   # name: The Bar
-;;       # binding: C-c M-l
-;;
-;;  D:   # name: Baz
-;;       # key: baz
-;;
-;;  keyhash       namehashes(3)      yas--template structs(4)
-;;  -----------------------------------------------------
-;;                                            __________
-;;                                           /          \
-;;  "foo"      --->  "The Foo" --->  [yas--template A]   |
-;;                   "Mrs Foo" --->  [yas--template B]   |
-;;                                                      |
-;;  [C-c M-l]  --->  "The Foo" -------------------------/
-;;                   "The Bar" --->  [yas--template C]
-;;
-;;  "baz"      --->  "Baz"     --->  [yas--template D]
-;;
-;; Additionally, since uuid defaults to the name, we have a
-;; `yas--table-uuidhash' for TABLE
-;;
-;; uuidhash       yas--template structs
-;; -------------------------------
-;; "The Foo" ---> [yas--template A]
-;; "Mrs Foo" ---> [yas--template B]
-;; "The Bar" ---> [yas--template C]
-;; "Baz"     ---> [yas--template D]
-;;
-;; FIXME: the more I look at this data-structure the more I think I'm
-;; stupid. There has to be an easier way (but beware lots of code
-;; depends on this).
-;;
-(defun yas--remove-template-by-uuid (table uuid)
-  "Remove from TABLE a template identified by UUID."
-  (let ((template (gethash uuid (yas--table-uuidhash table))))
-    (when template
-      (let* ((name                (yas--template-name template))
-             (empty-keys          nil))
-        ;; Remove the name from each of the targeted namehashes
-        ;;
-        (maphash #'(lambda (k v)
-                     (let ((template (gethash name v)))
-                       (when (and template
-                                  (equal uuid (yas--template-uuid template)))
-                         (remhash name v)
-                         (when (zerop (hash-table-count v))
-                           (push k empty-keys)))))
-                 (yas--table-hash table))
-        ;; Remove the namehash themselves if they've become empty
-        ;;
-        (dolist (key empty-keys)
-          (when (vectorp key)
-            (define-key (yas--table-direct-keymap table) key nil))
-          (remhash key (yas--table-hash table)))
-
-        ;; Finally, remove the uuid from the uuidhash
-        ;;
-        (remhash uuid (yas--table-uuidhash table))))))
-
-(defconst yas-maybe-expand-from-keymap
-  '(menu-item "" yas-expand-from-keymap
-              :filter yas--maybe-expand-from-keymap-filter))
-
-(defun yas--add-template (table template)
-  "Store in TABLE the snippet template TEMPLATE.
-
-KEY can be a string (trigger key) of a vector (direct
-keybinding)."
-  (let ((name (yas--template-name template))
-        (key (yas--template-key template))
-        (keybinding (yas--template-keybinding template))
-        (_menu-binding-pair (yas--template-menu-binding-pair-get-create template)))
-    (dolist (k (remove nil (list key keybinding)))
-      (puthash name
-               template
-               (or (gethash k
-                            (yas--table-hash table))
-                   (puthash k
-                            (make-hash-table :test 'equal)
-                            (yas--table-hash table))))
-      (when (vectorp k)
-        (define-key (yas--table-direct-keymap table) k yas-maybe-expand-from-keymap)))
-
-    ;; Update TABLE's `yas--table-uuidhash'
-    (puthash (yas--template-uuid template)
-             template
-             (yas--table-uuidhash table))))
-
-(defun yas--update-template (table template)
-  "Add or update TEMPLATE in TABLE.
-
-Also takes care of adding and updating to the associated menu.
-Return TEMPLATE."
-  ;; Remove from table by uuid
-  ;;
-  (yas--remove-template-by-uuid table (yas--template-uuid template))
-  ;; Add to table again
-  ;;
-  (yas--add-template table template)
-  ;; Take care of the menu
-  ;;
-  (yas--update-template-menu table template)
-  template)
-
-(defun yas--update-template-menu (table template)
-  "Update every menu-related for TEMPLATE."
-  (let ((menu-binding-pair (yas--template-menu-binding-pair-get-create template))
-        (key (yas--template-key template))
-        (keybinding (yas--template-keybinding template)))
-    ;; The snippet might have changed name or keys, so update
-    ;; user-visible strings
-    ;;
-    (unless (eq (cdr menu-binding-pair) :none)
-      ;; the menu item name
-      ;;
-      (setf (cl-cadar menu-binding-pair) (yas--template-name template))
-      ;; the :keys information (also visible to the user)
-      (setf (cl-getf (cdr (car menu-binding-pair)) :keys)
-            (or (and keybinding (key-description keybinding))
-                (and key (concat key yas-trigger-symbol))))))
-  (unless (yas--template-menu-managed-by-yas-define-menu template)
-    (let ((menu-keymap
-           (yas--menu-keymap-get-create (yas--table-mode table)
-                                        (mapcar #'yas--table-mode
-                                                (yas--table-parents table))))
-          (group (yas--template-group template)))
-      ;; Remove from menu keymap
-      ;;
-      (cl-assert menu-keymap)
-      (yas--delete-from-keymap menu-keymap (yas--template-uuid template))
-
-      ;; Add necessary subgroups as necessary.
-      ;;
-      (dolist (subgroup group)
-        (let ((subgroup-keymap (lookup-key menu-keymap (vector (make-symbol subgroup)))))
-          (unless (and subgroup-keymap
-                       (keymapp subgroup-keymap))
-            (setq subgroup-keymap (make-sparse-keymap))
-            (define-key menu-keymap (vector (make-symbol subgroup))
-              `(menu-item ,subgroup ,subgroup-keymap)))
-          (setq menu-keymap subgroup-keymap)))
-
-      ;; Add this entry to the keymap
-      ;;
-      (define-key menu-keymap
-        (vector (make-symbol (yas--template-uuid template)))
-        (car (yas--template-menu-binding-pair template))))))
-
-(defun yas--namehash-templates-alist (namehash)
-  "Return NAMEHASH as an alist."
-  (let (alist)
-    (maphash #'(lambda (k v)
-                 (push (cons k v) alist))
-             namehash)
-    alist))
-
-(defun yas--fetch (table key)
-  "Fetch templates in TABLE by KEY.
-
-Return a list of cons (NAME . TEMPLATE) where NAME is a
-string and TEMPLATE is a `yas--template' structure."
-  (let* ((keyhash (yas--table-hash table))
-         (namehash (and keyhash (gethash key keyhash))))
-    (when namehash
-      (yas--filter-templates-by-condition (yas--namehash-templates-alist namehash)))))
-
-
-;;; Filtering/condition logic
-
-(defun yas--eval-condition (condition)
-  (condition-case err
-      (save-excursion
-        (save-restriction
-          (save-match-data
-            (eval condition))))
-    (error (progn
-             (yas--message 1 "Error in condition evaluation: %s" (error-message-string err))
-             nil))))
-
-
-(defun yas--filter-templates-by-condition (templates)
-  "Filter the templates using the applicable condition.
-
-TEMPLATES is a list of cons (NAME . TEMPLATE) where NAME is a
-string and TEMPLATE is a `yas--template' structure.
-
-This function implements the rules described in
-`yas-buffer-local-condition'.  See that variables documentation."
-  (let ((requirement (yas--require-template-specific-condition-p)))
-    (if (eq requirement 'always)
-        templates
-      (cl-remove-if-not (lambda (pair)
-                          (yas--template-can-expand-p
-                           (yas--template-condition (cdr pair)) requirement))
-                        templates))))
-
-(defun yas--require-template-specific-condition-p ()
-  "Decide if this buffer requests/requires snippet-specific
-conditions to filter out potential expansions."
-  (if (eq 'always yas-buffer-local-condition)
-      'always
-    (let ((local-condition (or (and (consp yas-buffer-local-condition)
-                                    (yas--eval-condition yas-buffer-local-condition))
-                               yas-buffer-local-condition)))
-      (when local-condition
-        (if (eq local-condition t)
-            t
-          (and (consp local-condition)
-               (eq 'require-snippet-condition (car local-condition))
-               (symbolp (cdr local-condition))
-               (cdr local-condition)))))))
-
-(defun yas--template-can-expand-p (condition requirement)
-  "Evaluate CONDITION and REQUIREMENT and return a boolean."
-  (let* ((result (or (null condition)
-                     (yas--eval-condition condition))))
-    (cond ((eq requirement t)
-           result)
-          (t
-           (eq requirement result)))))
-
-(defun yas--table-templates (table)
-  (when table
-    (let ((acc (list)))
-      (maphash #'(lambda (_key namehash)
-                   (maphash #'(lambda (name template)
-                                (push (cons name template) acc))
-                            namehash))
-               (yas--table-hash table))
-      (yas--filter-templates-by-condition acc))))
-
-(defun yas--templates-for-key-at-point ()
-  "Find `yas--template' objects for any trigger keys preceding point.
-Returns (TEMPLATES START END). This function respects
-`yas-key-syntaxes', which see."
-  (save-excursion
-    (let ((original (point))
-          (methods yas-key-syntaxes)
-          (templates)
-          (method))
-      (while (and methods
-                  (not templates))
-        (unless (eq method (car methods))
-          ;; TRICKY: `eq'-ness test means we can only be here if
-          ;; `method' is a function that returned `again', and hence
-          ;; don't revert back to original position as per
-          ;; `yas-key-syntaxes'.
-          (goto-char original))
-        (setq method (car methods))
-        (cond ((stringp method)
-               (skip-syntax-backward method)
-               (setq methods (cdr methods)))
-              ((functionp method)
-               (unless (eq (funcall method original)
-                           'again)
-                 (setq methods (cdr methods))))
-              (t
-               (setq methods (cdr methods))
-               (yas--warning "Invalid element `%s' in `yas-key-syntaxes'" method)))
-        (let ((possible-key (buffer-substring-no-properties (point) original)))
-          (save-excursion
-            (goto-char original)
-            (setq templates
-                  (cl-mapcan (lambda (table)
-                               (yas--fetch table possible-key))
-                             (yas--get-snippet-tables))))))
-      (when templates
-        (list templates (point) original)))))
-
-(defun yas--table-all-keys (table)
-  "Get trigger keys of all active snippets in TABLE."
-  (let ((acc))
-    (maphash #'(lambda (key namehash)
-                 (when (yas--filter-templates-by-condition (yas--namehash-templates-alist namehash))
-                   (push key acc)))
-             (yas--table-hash table))
-    acc))
-
-(defun yas--table-mode (table)
-  (intern (yas--table-name table)))
-
-
-;;; Internal functions and macros:
-
-(defun yas--remove-misc-free-from-undo (old-undo-list)
-  "Tries to work around Emacs Bug#30931.
-Helper function for `yas--save-restriction-and-widen'."
-  ;; If Bug#30931 is unfixed, we get (#<Lisp_Misc_Free> . INTEGER)
-  ;; entries in the undo list.  If we call `type-of' on the
-  ;; Lisp_Misc_Free object then Emacs aborts, so try to find it by
-  ;; checking that its type is none of the expected ones.
-  (when (consp buffer-undo-list)
-    (let* ((prev buffer-undo-list)
-           (undo-list prev))
-      (while (and (consp undo-list)
-                  ;; Only check new entries.
-                  (not (eq undo-list old-undo-list)))
-        (let ((entry (pop undo-list)))
-          (when (consp entry)
-            (let ((head (car entry)))
-              (unless (or (stringp head)
-                          (markerp head)
-                          (integerp head)
-                          (symbolp head)
-                          (not (integerp (cdr entry))))
-                ;; (message "removing misc free %S" entry)
-                (setcdr prev undo-list)))))
-        (setq prev undo-list)))))
-
-(defmacro yas--save-restriction-and-widen (&rest body)
-  "Equivalent to (save-restriction (widen) BODY).
-Also tries to work around Emacs Bug#30931."
-  (declare (debug (body)) (indent 0))
-  ;; Disable garbage collection, since it could cause an abort.
-  `(let ((gc-cons-threshold most-positive-fixnum)
-         (old-undo-list buffer-undo-list))
-     (prog1 (save-restriction
-              (widen)
-              ,@body)
-       (yas--remove-misc-free-from-undo old-undo-list))))
-
-(defun yas--eval-for-string (form)
-  "Evaluate FORM and convert the result to string."
-  (let ((debug-on-error (and (not (memq yas-good-grace '(t inline)))
-                             debug-on-error)))
-    (condition-case oops
-        (save-excursion
-          (yas--save-restriction-and-widen
-            (save-match-data
-              (let ((result (eval form)))
-                (when result
-                  (format "%s" result))))))
-      ((debug error) (cdr oops)))))
-
-(defun yas--eval-for-effect (form)
-  (yas--safely-call-fun (apply-partially #'eval form)))
-
-(defun yas--read-lisp (string &optional nil-on-error)
-  "Read STRING as a elisp expression and return it.
-
-In case STRING in an invalid expression and NIL-ON-ERROR is nil,
-return an expression that when evaluated will issue an error."
-  (condition-case err
-      (read string)
-    (error (and (not nil-on-error)
-                `(error (error-message-string ,err))))))
-
-(defun yas--read-keybinding (keybinding)
-  "Read KEYBINDING as a snippet keybinding, return a vector."
-  (when (and keybinding
-             (not (string-match "keybinding" keybinding)))
-    (condition-case err
-        (let ((res (or (and (string-match "^\\[.*\\]$" keybinding)
-                            (read keybinding))
-                       (read-kbd-macro keybinding 'need-vector))))
-          res)
-      (error
-       (yas--message 2 "warning: keybinding \"%s\" invalid since %s."
-                keybinding (error-message-string err))
-       nil))))
-
-(defun yas--table-get-create (mode)
-  "Get or create the snippet table corresponding to MODE."
-  (let ((table (gethash mode
-                        yas--tables)))
-    (unless table
-      (setq table (yas--make-snippet-table (symbol-name mode)))
-      (puthash mode table yas--tables)
-      (push (cons (intern (format "yas--direct-%s" mode))
-                  (yas--table-direct-keymap table))
-            yas--direct-keymaps))
-    table))
-
-(defun yas--get-snippet-tables (&optional mode)
-  "Get snippet tables for MODE.
-
-MODE defaults to the current buffer's `major-mode'.
-
-Return a list of `yas--table' objects.  The list of modes to
-consider is returned by `yas--modes-to-activate'"
-  (remove nil
-          (mapcar #'(lambda (name)
-                      (gethash name yas--tables))
-                  (yas--modes-to-activate mode))))
-
-(defun yas--menu-keymap-get-create (mode &optional parents)
-  "Get or create the menu keymap for MODE and its PARENTS.
-
-This may very well create a plethora of menu keymaps and arrange
-them all in `yas--menu-table'"
-  (let* ((menu-keymap (or (gethash mode yas--menu-table)
-                          (puthash mode (make-sparse-keymap) yas--menu-table))))
-    (mapc #'yas--menu-keymap-get-create parents)
-    (define-key yas--minor-mode-menu (vector mode)
-        `(menu-item ,(symbol-name mode) ,menu-keymap
-                    :visible (yas--show-menu-p ',mode)))
-    menu-keymap))
-
-
-;;; Template-related and snippet loading functions
-
-(defun yas--parse-template (&optional file)
-  "Parse the template in the current buffer.
-
-Optional FILE is the absolute file name of the file being
-parsed.
-
-Optional GROUP is the group where the template is to go,
-otherwise we attempt to calculate it from FILE.
-
-Return a snippet-definition, i.e. a list
-
- (KEY TEMPLATE NAME CONDITION GROUP VARS LOAD-FILE KEYBINDING UUID)
-
-If the buffer contains a line of \"# --\" then the contents above
-this line are ignored. Directives can set most of these with the syntax:
-
-# directive-name : directive-value
-
-Here's a list of currently recognized directives:
-
- * type
- * name
- * contributor
- * condition
- * group
- * key
- * expand-env
- * binding
- * uuid"
-  (goto-char (point-min))
-  (let* ((type 'snippet)
-         (name (and file
-                    (file-name-nondirectory file)))
-         (key nil)
-         template
-         bound
-         condition
-         (group (and file
-                     (yas--calculate-group file)))
-         expand-env
-         binding
-         uuid)
-    (if (re-search-forward "^# --\\s-*\n" nil t)
-        (progn (setq template
-                     (buffer-substring-no-properties (point)
-                                                     (point-max)))
-               (setq bound (point))
-               (goto-char (point-min))
-               (while (re-search-forward "^# *\\([^ ]+?\\) *: *\\(.*?\\)[[:space:]]*$" bound t)
-                 (when (string= "uuid" (match-string-no-properties 1))
-                   (setq uuid (match-string-no-properties 2)))
-                 (when (string= "type" (match-string-no-properties 1))
-                   (setq type (if (string= "command" (match-string-no-properties 2))
-                                  'command
-                                'snippet)))
-                 (when (string= "key" (match-string-no-properties 1))
-                   (setq key (match-string-no-properties 2)))
-                 (when (string= "name" (match-string-no-properties 1))
-                   (setq name (match-string-no-properties 2)))
-                 (when (string= "condition" (match-string-no-properties 1))
-                   (setq condition (yas--read-lisp (match-string-no-properties 2))))
-                 (when (string= "group" (match-string-no-properties 1))
-                   (setq group (match-string-no-properties 2)))
-                 (when (string= "expand-env" (match-string-no-properties 1))
-                   (setq expand-env (yas--read-lisp (match-string-no-properties 2)
-                                                   'nil-on-error)))
-                 (when (string= "binding" (match-string-no-properties 1))
-                   (setq binding (match-string-no-properties 2)))))
-      (setq template
-            (buffer-substring-no-properties (point-min) (point-max))))
-    (unless (or key binding)
-      (setq key (and file (file-name-nondirectory file))))
-    (when (eq type 'command)
-      (setq template (yas--read-lisp (concat "(progn" template ")"))))
-    (when group
-      (setq group (split-string group "\\.")))
-    (list key template name condition group expand-env file binding uuid)))
-
-(defun yas--calculate-group (file)
-  "Calculate the group for snippet file path FILE."
-  (let* ((dominating-dir (locate-dominating-file file
-                                                 ".yas-make-groups"))
-         (extra-path (and dominating-dir
-                          (file-relative-name file dominating-dir)))
-         (extra-dir (and extra-path
-                         (file-name-directory extra-path)))
-         (group (and extra-dir
-                     (replace-regexp-in-string "/"
-                                               "."
-                                               (directory-file-name extra-dir)))))
-    group))
-
-(defun yas--subdirs (directory &optional filep)
-  "Return subdirs or files of DIRECTORY according to FILEP."
-  (cl-remove-if (lambda (file)
-                  (or (string-match "\\`\\."
-                                    (file-name-nondirectory file))
-                      (string-match "\\`#.*#\\'"
-                                    (file-name-nondirectory file))
-                      (string-match "~\\'"
-                                    (file-name-nondirectory file))
-                      (if filep
-                          (file-directory-p file)
-                        (not (file-directory-p file)))))
-                (directory-files directory t)))
-
-(defun yas--make-menu-binding (template)
-  (let ((mode (yas--table-mode (yas--template-table template))))
-    `(lambda () (interactive) (yas--expand-or-visit-from-menu ',mode ,(yas--template-uuid template)))))
-
-(defun yas--expand-or-visit-from-menu (mode uuid)
-  (let* ((table (yas--table-get-create mode))
-         (yas--current-template (and table
-                                    (gethash uuid (yas--table-uuidhash table)))))
-    (when yas--current-template
-      (if yas-visit-from-menu
-          (yas--visit-snippet-file-1 yas--current-template)
-        (let ((where (if (region-active-p)
-                         (cons (region-beginning) (region-end))
-                       (cons (point) (point)))))
-          (yas-expand-snippet (yas--template-content yas--current-template)
-                              (car where)
-                              (cdr where)
-                              (yas--template-expand-env yas--current-template)))))))
-
-(defun yas--key-from-desc (text)
-  "Return a yasnippet key from a description string TEXT."
-  (replace-regexp-in-string "\\(\\w+\\).*" "\\1" text))
-
-
-;;; Popping up for keys and templates
-
-(defun yas--prompt-for-template (templates &optional prompt)
-  "Interactively choose a template from the list TEMPLATES.
-
-TEMPLATES is a list of `yas--template'.
-
-Optional PROMPT sets the prompt to use."
-  (when templates
-    (setq templates
-          (sort templates #'(lambda (t1 t2)
-                              (< (length (yas--template-name t1))
-                                 (length (yas--template-name t2))))))
-    (cl-some (lambda (fn)
-               (funcall fn (or prompt "Choose a snippet: ")
-                        templates
-                        #'yas--template-name))
-             yas-prompt-functions)))
-
-(defun yas--prompt-for-keys (keys &optional prompt)
-  "Interactively choose a template key from the list KEYS.
-
-Optional PROMPT sets the prompt to use."
-  (when keys
-    (cl-some (lambda (fn)
-               (funcall fn (or prompt "Choose a snippet key: ") keys))
-             yas-prompt-functions)))
-
-(defun yas--prompt-for-table (tables &optional prompt)
-  "Interactively choose a table from the list TABLES.
-
-Optional PROMPT sets the prompt to use."
-  (when tables
-    (cl-some (lambda (fn)
-               (funcall fn (or prompt "Choose a snippet table: ")
-                        tables
-                        #'yas--table-name))
-             yas-prompt-functions)))
-
-(defun yas-x-prompt (prompt choices &optional display-fn)
-  "Display choices in a x-window prompt."
-  (when (and window-system choices)
-    ;; Let window position be recalculated to ensure that
-    ;; `posn-at-point' returns non-nil.
-    (redisplay)
-    (or
-     (x-popup-menu
-      (if (fboundp 'posn-at-point)
-          (let ((x-y (posn-x-y (posn-at-point (point)))))
-            (list (list (+ (car x-y) 10)
-                        (+ (cdr x-y) 20))
-                  (selected-window)))
-        t)
-      `(,prompt ("title"
-                 ,@(cl-mapcar (lambda (c d) `(,(concat "   " d) . ,c))
-                              choices
-                              (if display-fn (mapcar display-fn choices)
-                                choices)))))
-     (keyboard-quit))))
-
-(defun yas-maybe-ido-prompt (prompt choices &optional display-fn)
-  (when (bound-and-true-p ido-mode)
-    (yas-ido-prompt prompt choices display-fn)))
-
-(defun yas-ido-prompt (prompt choices &optional display-fn)
-  (require 'ido)
-  (yas-completing-prompt prompt choices display-fn #'ido-completing-read))
-
-(defun yas-dropdown-prompt (_prompt choices &optional display-fn)
-  (when (fboundp 'dropdown-list)
-    (let* ((formatted-choices
-            (if display-fn (mapcar display-fn choices) choices))
-           (n (dropdown-list formatted-choices)))
-      (if n (nth n choices)
-        (keyboard-quit)))))
-
-(defun yas-completing-prompt (prompt choices &optional display-fn completion-fn)
-  (let* ((formatted-choices
-          (if display-fn (mapcar display-fn choices) choices))
-         (chosen (funcall (or completion-fn #'completing-read)
-                          prompt formatted-choices
-                          nil 'require-match nil nil)))
-    (if (eq choices formatted-choices)
-        chosen
-      (nth (or (cl-position chosen formatted-choices :test #'string=) 0)
-           choices))))
-
-(defun yas-no-prompt (_prompt choices &optional _display-fn)
-  (cl-first choices))
-
-
-;;; Defining snippets
-;; This consists of creating and registering `yas--template' objects in the
-;; correct tables.
-;;
-
-(defvar yas--creating-compiled-snippets nil)
-
-(defun yas--define-snippets-1 (snippet snippet-table)
-  "Helper for `yas-define-snippets'."
-  ;; Update the appropriate table.  Also takes care of adding the
-  ;; key indicators in the templates menu entry, if any.
-  (yas--update-template
-   snippet-table (apply #'yas--define-snippets-2 snippet-table snippet)))
-
-(defun yas-define-snippets (mode snippets)
-  "Define SNIPPETS for MODE.
-
-SNIPPETS is a list of snippet definitions, each taking the
-following form
-
- (KEY TEMPLATE NAME CONDITION GROUP EXPAND-ENV LOAD-FILE KEYBINDING UUID SAVE-FILE)
-
-Within these, only KEY and TEMPLATE are actually mandatory.
-
-TEMPLATE might be a Lisp form or a string, depending on whether
-this is a snippet or a snippet-command.
-
-CONDITION, EXPAND-ENV and KEYBINDING are Lisp forms, they have
-been `yas--read-lisp'-ed and will eventually be
-`yas--eval-for-string'-ed.
-
-The remaining elements are strings.
-
-FILE is probably of very little use if you're programatically
-defining snippets.
-
-UUID is the snippet's \"unique-id\". Loading a second snippet
-file with the same uuid would replace the previous snippet.
-
-You can use `yas--parse-template' to return such lists based on
-the current buffers contents."
-  (if yas--creating-compiled-snippets
-      (let ((print-length nil))
-        (insert ";;; Snippet definitions:\n;;;\n")
-        (dolist (snippet snippets)
-          ;; Fill in missing elements with nil.
-          (setq snippet (append snippet (make-list (- 10 (length snippet)) nil)))
-          ;; Move LOAD-FILE to SAVE-FILE because we will load from the
-          ;; compiled file, not LOAD-FILE.
-          (let ((load-file (nth 6 snippet)))
-            (setcar (nthcdr 6 snippet) nil)
-            (setcar (nthcdr 9 snippet) load-file)))
-        (insert (pp-to-string
-                 `(yas-define-snippets ',mode ',snippets)))
-        (insert "\n\n"))
-    ;; Normal case.
-    (let ((snippet-table (yas--table-get-create mode))
-          (template nil))
-      (dolist (snippet snippets)
-        (setq template (yas--define-snippets-1 snippet
-                                               snippet-table)))
-      template)))
-
-
-;;; Loading snippets from files
-
-(defun yas--template-get-file (template)
-  "Return TEMPLATE's LOAD-FILE or SAVE-FILE."
-  (or (yas--template-load-file template)
-      (let ((file (yas--template-save-file template)))
-        (when file
-          (yas--message 3 "%s has no load file, using save file, %s, instead."
-                        (yas--template-name template) file))
-        file)))
-
-(defun yas--load-yas-setup-file (file)
-  (if (not yas--creating-compiled-snippets)
-      ;; Normal case.
-      (load file 'noerror (<= yas-verbosity 4))
-    (let ((elfile (concat file ".el")))
-      (when (file-exists-p elfile)
-        (insert ";;; contents of the .yas-setup.el support file:\n;;;\n")
-        (insert-file-contents elfile)
-        (goto-char (point-max))))))
-
-(defun yas--define-parents (mode parents)
-  "Add PARENTS to the list of MODE's parents."
-  (puthash mode (cl-remove-duplicates
-                 (append parents
-                         (gethash mode yas--parents)))
-           yas--parents))
-
-(defun yas-load-directory (top-level-dir &optional use-jit interactive)
-  "Load snippets in directory hierarchy TOP-LEVEL-DIR.
-
-Below TOP-LEVEL-DIR each directory should be a mode name.
-
-With prefix argument USE-JIT do jit-loading of snippets."
-  (interactive
-   (list (read-directory-name "Select the root directory: " nil nil t)
-         current-prefix-arg t))
-  (unless yas-snippet-dirs
-    (setq yas-snippet-dirs top-level-dir))
-  (let ((impatient-buffers))
-    (dolist (dir (yas--subdirs top-level-dir))
-      (let* ((major-mode-and-parents (yas--compute-major-mode-and-parents
-                                      (concat dir "/dummy")))
-             (mode-sym (car major-mode-and-parents))
-             (parents (cdr major-mode-and-parents)))
-        ;; Attention: The parents and the menus are already defined
-        ;; here, even if the snippets are later jit-loaded.
-        ;;
-        ;; * We need to know the parents at this point since entering a
-        ;;   given mode should jit load for its parents
-        ;;   immediately. This could be reviewed, the parents could be
-        ;;   discovered just-in-time-as well
-        ;;
-        ;; * We need to create the menus here to support the `full'
-        ;;   option to `yas-use-menu' (all known snippet menus are shown to the user)
-        ;;
-        (yas--define-parents mode-sym parents)
-        (yas--menu-keymap-get-create mode-sym)
-        (let ((fun (apply-partially #'yas--load-directory-1 dir mode-sym)))
-          (if use-jit
-              (yas--schedule-jit mode-sym fun)
-            (funcall fun)))
-        ;; Look for buffers that are already in `mode-sym', and so
-        ;; need the new snippets immediately...
-        ;;
-        (when use-jit
-          (cl-loop for buffer in (buffer-list)
-                   do (with-current-buffer buffer
-                        (when (eq major-mode mode-sym)
-                          (yas--message 4 "Discovered there was already %s in %s" buffer mode-sym)
-                          (push buffer impatient-buffers)))))))
-    ;; ...after TOP-LEVEL-DIR has been completely loaded, call
-    ;; `yas--load-pending-jits' in these impatient buffers.
-    ;;
-    (cl-loop for buffer in impatient-buffers
-             do (with-current-buffer buffer (yas--load-pending-jits))))
-  (when interactive
-    (yas--message 3 "Loaded snippets from %s." top-level-dir)))
-
-(defun yas--load-directory-1 (directory mode-sym)
-  "Recursively load snippet templates from DIRECTORY."
-  (if yas--creating-compiled-snippets
-      (let ((output-file (expand-file-name ".yas-compiled-snippets.el"
-                                           directory)))
-        (with-temp-file output-file
-          (insert (format ";;; Compiled snippets and support files for `%s'\n"
-                          mode-sym))
-          (yas--load-directory-2 directory mode-sym)
-          (insert (format ";;; Do not edit! File generated at %s\n"
-                          (current-time-string)))))
-    ;; Normal case.
-    (unless (file-exists-p (expand-file-name ".yas-skip" directory))
-      (unless (and (load (expand-file-name ".yas-compiled-snippets" directory) 'noerror (<= yas-verbosity 3))
-                   (progn (yas--message 4 "Loaded compiled snippets from %s" directory) t))
-        (yas--message 4 "Loading snippet files from %s" directory)
-        (yas--load-directory-2 directory mode-sym)))))
-
-(defun yas--load-directory-2 (directory mode-sym)
-  ;; Load .yas-setup.el files wherever we find them
-  ;;
-  (yas--load-yas-setup-file (expand-file-name ".yas-setup" directory))
-  (let* ((default-directory directory)
-         (snippet-defs nil))
-    ;; load the snippet files
-    ;;
-    (with-temp-buffer
-      (dolist (file (yas--subdirs directory 'no-subdirs-just-files))
-        (when (file-readable-p file)
-          ;; Erase the buffer instead of passing non-nil REPLACE to
-          ;; `insert-file-contents' (avoids Emacs bug #23659).
-          (erase-buffer)
-          (insert-file-contents file)
-          (push (yas--parse-template file)
-                snippet-defs))))
-    (when snippet-defs
-      (yas-define-snippets mode-sym
-                           snippet-defs))
-    ;; now recurse to a lower level
-    ;;
-    (dolist (subdir (yas--subdirs directory))
-      (yas--load-directory-2 subdir
-                            mode-sym))))
-
-(defun yas--load-snippet-dirs (&optional nojit)
-  "Reload the directories listed in `yas-snippet-dirs' or
-prompt the user to select one."
-  (let (errors)
-    (if (null yas-snippet-dirs)
-        (call-interactively 'yas-load-directory)
-      (when (member yas--default-user-snippets-dir yas-snippet-dirs)
-        (make-directory yas--default-user-snippets-dir t))
-      (dolist (directory (reverse (yas-snippet-dirs)))
-        (cond ((file-directory-p directory)
-               (yas-load-directory directory (not nojit))
-               (if nojit
-                   (yas--message 4 "Loaded %s" directory)
-                 (yas--message 4 "Prepared just-in-time loading for %s" directory)))
-              (t
-               (push (yas--message 1 "Check your `yas-snippet-dirs': %s is not a directory" directory) errors)))))
-    errors))
-
-(defun yas-reload-all (&optional no-jit interactive)
-  "Reload all snippets and rebuild the YASnippet menu.
-
-When NO-JIT is non-nil force immediate reload of all known
-snippets under `yas-snippet-dirs', otherwise use just-in-time
-loading.
-
-When called interactively, use just-in-time loading when given a
-prefix argument."
-  (interactive (list (not current-prefix-arg) t))
-  (catch 'abort
-    (let ((errors)
-          (snippet-editing-buffers
-           (cl-remove-if-not (lambda (buffer)
-                               (with-current-buffer buffer
-                                 yas--editing-template))
-                             (buffer-list))))
-      ;; Warn if there are buffers visiting snippets, since reloading will break
-      ;; any on-line editing of those buffers.
-      ;;
-      (when snippet-editing-buffers
-          (if interactive
-              (if (y-or-n-p "Some buffers editing live snippets, close them and proceed with reload? ")
-                  (mapc #'kill-buffer snippet-editing-buffers)
-                (yas--message 1 "Aborted reload...")
-                (throw 'abort nil))
-            ;; in a non-interactive use, at least set
-            ;; `yas--editing-template' to nil, make it guess it next time around
-            (mapc #'(lambda (buffer)
-                      (with-current-buffer buffer
-                        (kill-local-variable 'yas--editing-template)))
-                  (buffer-list))))
-
-      ;; Empty all snippet tables and parenting info
-      ;;
-      (setq yas--tables (make-hash-table))
-      (setq yas--parents (make-hash-table))
-
-      ;; Before killing `yas--menu-table' use its keys to cleanup the
-      ;; mode menu parts of `yas--minor-mode-menu' (thus also cleaning
-      ;; up `yas-minor-mode-map', which points to it)
-      ;;
-      (maphash #'(lambda (menu-symbol _keymap)
-                   (define-key yas--minor-mode-menu (vector menu-symbol) nil))
-               yas--menu-table)
-      ;; Now empty `yas--menu-table' as well
-      (setq yas--menu-table (make-hash-table))
-
-      ;; Cancel all pending 'yas--scheduled-jit-loads'
-      ;;
-      (setq yas--scheduled-jit-loads (make-hash-table))
-
-      ;; Reload the directories listed in `yas-snippet-dirs' or prompt
-      ;; the user to select one.
-      ;;
-      (setq errors (yas--load-snippet-dirs no-jit))
-      ;; Reload the direct keybindings
-      ;;
-      (yas-direct-keymaps-reload)
-
-      (run-hooks 'yas-after-reload-hook)
-      (let ((no-snippets
-             (cl-every (lambda (table) (= (hash-table-count table) 0))
-                       (list yas--scheduled-jit-loads
-                             yas--parents yas--tables))))
-        (yas--message (if (or no-snippets errors) 2 3)
-                      (if no-jit "Snippets loaded %s."
-                        "Prepared just-in-time loading of snippets %s.")
-                      (cond (errors
-                             "with some errors.  Check *Messages*")
-                            (no-snippets
-                             "(but no snippets found)")
-                            (t
-                             "successfully")))))))
-
-(defvar yas-after-reload-hook nil
-  "Hooks run after `yas-reload-all'.")
-
-(defun yas--load-pending-jits ()
-  (dolist (mode (yas--modes-to-activate))
-    (let ((funs (reverse (gethash mode yas--scheduled-jit-loads))))
-      ;; must reverse to maintain coherence with `yas-snippet-dirs'
-      (dolist (fun funs)
-        (yas--message 4 "Loading for `%s', just-in-time: %s!" mode fun)
-        (funcall fun))
-      (remhash mode yas--scheduled-jit-loads))))
-
-(defun yas-escape-text (text)
-  "Escape TEXT for snippet."
-  (when text
-    (replace-regexp-in-string "[\\$]" "\\\\\\&" text)))
-
-
-;;; Snippet compilation function
-
-(defun yas-compile-directory (top-level-dir)
-  "Create .yas-compiled-snippets.el files under subdirs of TOP-LEVEL-DIR.
-
-This works by stubbing a few functions, then calling
-`yas-load-directory'."
-  (interactive "DTop level snippet directory?")
-  (let ((yas--creating-compiled-snippets t))
-    (yas-load-directory top-level-dir nil)))
-
-(defun yas-recompile-all ()
-  "Compile every dir in `yas-snippet-dirs'."
-  (interactive)
-  (mapc #'yas-compile-directory (yas-snippet-dirs)))
-
-
-;;; JIT loading
-;;;
-
-(defvar yas--scheduled-jit-loads (make-hash-table)
-  "Alist of mode-symbols to forms to be evaled when `yas-minor-mode' kicks in.")
-
-(defun yas--schedule-jit (mode fun)
-  (push fun (gethash mode yas--scheduled-jit-loads)))
-
-
-
-;;; Some user level functions
-
-(defun yas-about ()
-  (interactive)
-  (message "yasnippet (version %s) -- pluskid/joaotavora/npostavs"
-           (or (ignore-errors (car (let ((default-directory yas--loaddir))
-                                     (process-lines "git" "describe"
-                                                    "--tags" "--dirty"))))
-               (when (and (featurep 'package)
-                          (fboundp 'package-desc-version)
-                          (fboundp 'package-version-join))
-                 (defvar package-alist)
-                 (ignore-errors
-                   (let* ((yas-pkg (cdr (assq 'yasnippet package-alist)))
-                          (version (package-version-join
-                                    (package-desc-version (car yas-pkg)))))
-                     ;; Special case for MELPA's bogus version numbers.
-                     (if (string-match "\\`20..[01][0-9][0-3][0-9][.][0-9]\\{3,4\\}\\'"
-                                       version)
-                         (concat yas--version "-snapshot" version)
-                       version))))
-               yas--version)))
-
-
-;;; Apropos snippet menu:
-;;
-;; The snippet menu keymaps are stored by mode in hash table called
-;; `yas--menu-table'. They are linked to the main menu in
-;; `yas--menu-keymap-get-create' and are initially created empty,
-;; reflecting the table hierarchy.
-;;
-;; They can be populated in two mutually exclusive ways: (1) by
-;; reading `yas--template-group', which in turn is populated by the "#
-;; group:" directives of the snippets or the ".yas-make-groups" file
-;; or (2) by using a separate `yas-define-menu' call, which declares a
-;; menu structure based on snippets uuids.
-;;
-;; Both situations are handled in `yas--update-template-menu', which
-;; uses the predicate `yas--template-menu-managed-by-yas-define-menu'
-;; that can tell between the two situations.
-;;
-;; Note:
-;;
-;; * if `yas-define-menu' is used it must run before
-;;   `yas-define-snippets' and the UUIDS must match, otherwise we get
-;;   duplicate entries. The `yas--template' objects are created in
-;;   `yas-define-menu', holding nothing but the menu entry,
-;;   represented by a pair of ((menu-item NAME :keys KEYS) TYPE) and
-;;   stored in `yas--template-menu-binding-pair'.  The (menu-item ...)
-;;   part is then stored in the menu keymap itself which make the item
-;;   appear to the user.  These limitations could probably be revised.
-;;
-;; * The `yas--template-perm-group' slot is only used in
-;;   `yas-describe-tables'.
-;;
-(defun yas--template-menu-binding-pair-get-create (template &optional type)
-  "Get TEMPLATE's menu binding or assign it a new one.
-
-TYPE may be `:stay', signaling this menu binding should be
-static in the menu."
-  (or (yas--template-menu-binding-pair template)
-      (let (;; (key (yas--template-key template))
-            ;; (keybinding (yas--template-keybinding template))
-            )
-        (setf (yas--template-menu-binding-pair template)
-              (cons `(menu-item ,(or (yas--template-name template)
-                                     (yas--template-uuid template))
-                                ,(yas--make-menu-binding template)
-                                :keys ,nil)
-                    type)))))
-(defun yas--template-menu-managed-by-yas-define-menu (template)
-  "Non-nil if TEMPLATE's menu entry was included in a `yas-define-menu' call."
-  (cdr (yas--template-menu-binding-pair template)))
-
-
-(defun yas--show-menu-p (mode)
-  (cond ((eq yas-use-menu 'abbreviate)
-         (cl-find mode
-                  (mapcar #'yas--table-mode
-                          (yas--get-snippet-tables))))
-        (yas-use-menu t)))
-
-(defun yas--delete-from-keymap (keymap uuid)
-  "Recursively delete items with UUID from KEYMAP and its submenus."
-
-  ;; XXX: This used to skip any submenus named \"parent mode\"
-  ;;
-  ;; First of all, recursively enter submenus, i.e. the tree is
-  ;; searched depth first so that stale submenus can be found in the
-  ;; higher passes.
-  ;;
-  (mapc #'(lambda (item)
-            (when (and (consp (cdr-safe item))
-                       (keymapp (nth 2 (cdr item))))
-              (yas--delete-from-keymap (nth 2 (cdr item)) uuid)))
-        (cdr keymap))
-  ;; Set the uuid entry to nil
-  ;;
-  (define-key keymap (vector (make-symbol uuid)) nil)
-  ;; Destructively modify keymap
-  ;;
-  (setcdr keymap (cl-delete-if (lambda (item)
-                                 (cond ((not (listp item)) nil)
-                                       ((null (cdr item)))
-                                       ((and (keymapp (nth 2 (cdr item)))
-                                             (null (cdr (nth 2 (cdr item))))))))
-                               (cdr keymap))))
-
-(defun yas-define-menu (mode menu &optional omit-items)
-  "Define a snippet menu for MODE according to MENU, omitting OMIT-ITEMS.
-
-MENU is a list, its elements can be:
-
-- (yas-item UUID) : Creates an entry the snippet identified with
-  UUID.  The menu entry for a snippet thus identified is
-  permanent, i.e. it will never move (be reordered) in the menu.
-
-- (yas-separator) : Creates a separator
-
-- (yas-submenu NAME SUBMENU) : Creates a submenu with NAME,
-  SUBMENU has the same form as MENU.  NAME is also added to the
-  list of groups of the snippets defined thereafter.
-
-OMIT-ITEMS is a list of snippet uuids that will always be
-omitted from MODE's menu, even if they're manually loaded."
-  (let* ((table (yas--table-get-create mode))
-         (hash (yas--table-uuidhash table)))
-    (yas--define-menu-1 table
-                        (yas--menu-keymap-get-create mode)
-                        menu
-                        hash)
-    (dolist (uuid omit-items)
-      (let ((template (or (gethash uuid hash)
-                          (puthash uuid
-                                   (yas--make-template :table table
-                                                       :uuid uuid)
-                                   hash))))
-        (setf (yas--template-menu-binding-pair template) (cons nil :none))))))
-
-(defun yas--define-menu-1 (table menu-keymap menu uuidhash &optional group-list)
-  "Helper for `yas-define-menu'."
-  (cl-loop
-   for (type name submenu) in (reverse menu)
-   collect (cond
-            ((or (eq type 'yas-item)
-                 (and yas-alias-to-yas/prefix-p
-                      (eq type 'yas/item)))
-             (let ((template (or (gethash name uuidhash)
-                                 (puthash name
-                                          (yas--make-template
-                                           :table table
-                                           :perm-group group-list
-                                           :uuid name)
-                                          uuidhash))))
-               (car (yas--template-menu-binding-pair-get-create
-                     template :stay))))
-            ((or (eq type 'yas-submenu)
-                 (and yas-alias-to-yas/prefix-p
-                      (eq type 'yas/submenu)))
-             (let ((subkeymap (make-sparse-keymap)))
-               (yas--define-menu-1 table subkeymap submenu uuidhash
-                                   (append group-list (list name)))
-               `(menu-item ,name ,subkeymap)))
-            ((or (eq type 'yas-separator)
-                 (and yas-alias-to-yas/prefix-p
-                      (eq type 'yas/separator)))
-             '(menu-item "----"))
-            (t (yas--message 1 "Don't know anything about menu entry %s" type)
-               nil))
-   into menu-entries
-   finally do (push (apply #'vector menu-entries) (cdr menu-keymap))))
-
-(defun yas--define (mode key template &optional name condition group)
-  "Define a snippet.  Expanding KEY into TEMPLATE.
-
-NAME is a description to this template.  Also update the menu if
-`yas-use-menu' is t.  CONDITION is the condition attached to
-this snippet.  If you attach a condition to a snippet, then it
-will only be expanded when the condition evaluated to non-nil."
-  (yas-define-snippets mode
-                       (list (list key template name condition group))))
-
-(defun yas-hippie-try-expand (first-time?)
-  "Integrate with hippie expand.
-
-Just put this function in `hippie-expand-try-functions-list'."
-  (when yas-minor-mode
-    (if (not first-time?)
-        (let ((yas-fallback-behavior 'return-nil))
-          (yas-expand))
-      (undo 1)
-      nil)))
-
-
-;;; Apropos condition-cache:
-;;;
-;;;
-;;;
-;;;
-(defmacro yas-define-condition-cache (func doc &rest body)
-  "Define a function FUNC with doc DOC and body BODY.
-BODY is executed at most once every snippet expansion attempt, to check
-expansion conditions.
-
-It doesn't make any sense to call FUNC programatically."
-  `(defun ,func () ,(if (and doc
-                             (stringp doc))
-                        (concat doc
-"\n\nFor use in snippets' conditions. Within each
-snippet-expansion routine like `yas-expand', computes actual
-value for the first time then always returns a cached value.")
-                      (setq body (cons doc body))
-                      nil)
-     (let ((timestamp-and-value (get ',func 'yas--condition-cache)))
-       (if (equal (car timestamp-and-value) yas--condition-cache-timestamp)
-           (cdr timestamp-and-value)
-         (let ((new-value (progn
-                            ,@body
-                            )))
-           (put ',func 'yas--condition-cache (cons yas--condition-cache-timestamp new-value))
-           new-value)))))
-
-(defalias 'yas-expand 'yas-expand-from-trigger-key)
-(defun yas-expand-from-trigger-key (&optional field)
-  "Expand a snippet before point.
-
-If no snippet expansion is possible, fall back to the behaviour
-defined in `yas-fallback-behavior'.
-
-Optional argument FIELD is for non-interactive use and is an
-object satisfying `yas--field-p' to restrict the expansion to."
-  (interactive)
-  (setq yas--condition-cache-timestamp (current-time))
-  (let (templates-and-pos)
-    (unless (and yas-expand-only-for-last-commands
-                 (not (member last-command yas-expand-only-for-last-commands)))
-      (setq templates-and-pos (if field
-                                  (save-restriction
-                                    (narrow-to-region (yas--field-start field)
-                                                      (yas--field-end field))
-                                    (yas--templates-for-key-at-point))
-                                (yas--templates-for-key-at-point))))
-    (if templates-and-pos
-        (yas--expand-or-prompt-for-template
-         (nth 0 templates-and-pos)
-         ;; Delete snippet key and active region when expanding.
-         (min (if (use-region-p) (region-beginning) most-positive-fixnum)
-              (nth 1 templates-and-pos))
-         (max (if (use-region-p) (region-end) most-negative-fixnum)
-              (nth 2 templates-and-pos)))
-      (yas--fallback))))
-
-(defun yas--maybe-expand-from-keymap-filter (cmd)
-  (let* ((yas--condition-cache-timestamp (current-time))
-         (vec (cl-subseq (this-command-keys-vector)
-                         (if current-prefix-arg
-                             (length (this-command-keys))
-                           0)))
-         (templates (cl-mapcan (lambda (table)
-                                 (yas--fetch table vec))
-                               (yas--get-snippet-tables))))
-    (if templates (or cmd templates))))
-
-(defun yas-expand-from-keymap ()
-  "Directly expand some snippets, searching `yas--direct-keymaps'."
-  (interactive)
-  (setq yas--condition-cache-timestamp (current-time))
-  (let* ((templates (yas--maybe-expand-from-keymap-filter nil)))
-    (when templates
-      (yas--expand-or-prompt-for-template templates))))
-
-(defun yas--expand-or-prompt-for-template (templates &optional start end)
-  "Expand one of TEMPLATES from START to END.
-
-Prompt the user if TEMPLATES has more than one element, else
-expand immediately.  Common gateway for
-`yas-expand-from-trigger-key' and `yas-expand-from-keymap'."
-  (let ((yas--current-template (or (and (cl-rest templates) ;; more than one
-                                        (yas--prompt-for-template (mapcar #'cdr templates)))
-                                   (cdar templates))))
-    (when yas--current-template
-      (yas-expand-snippet (yas--template-content yas--current-template)
-                          start
-                          end
-                          (yas--template-expand-env yas--current-template)))))
-
-;; Apropos the trigger key and the fallback binding:
-;;
-;; When `yas-minor-mode-map' binds <tab>, that correctly overrides
-;; org-mode's <tab>, for example and searching for fallbacks correctly
-;; returns `org-cycle'. However, most other modes bind "TAB". TODO,
-;; improve this explanation.
-;;
-(defun yas--fallback ()
-  "Fallback after expansion has failed.
-
-Common gateway for `yas-expand-from-trigger-key' and
-`yas-expand-from-keymap'."
-  (cond ((eq yas-fallback-behavior 'return-nil)
-         ;; return nil
-         nil)
-        ((eq yas-fallback-behavior 'yas--fallback)
-         (error (concat "yasnippet fallback loop!\n"
-                        "This can happen when you bind `yas-expand' "
-                        "outside of the `yas-minor-mode-map'.")))
-        ((eq yas-fallback-behavior 'call-other-command)
-         (let* ((yas-fallback-behavior 'yas--fallback)
-                ;; Also bind `yas-minor-mode' to prevent fallback
-                ;; loops when other extensions use mechanisms similar
-                ;; to `yas--keybinding-beyond-yasnippet'. (github #525
-                ;; and #526)
-                ;;
-                (yas-minor-mode nil)
-                (beyond-yasnippet (yas--keybinding-beyond-yasnippet)))
-           (yas--message 4 "Falling back to %s"  beyond-yasnippet)
-           (cl-assert (or (null beyond-yasnippet) (commandp beyond-yasnippet)))
-           (setq this-command beyond-yasnippet)
-           (when beyond-yasnippet
-             (call-interactively beyond-yasnippet))))
-        ((and (listp yas-fallback-behavior)
-              (cdr yas-fallback-behavior)
-              (eq 'apply (car yas-fallback-behavior)))
-         (let ((command-or-fn (cadr yas-fallback-behavior))
-               (args (cddr yas-fallback-behavior))
-               (yas-fallback-behavior 'yas--fallback)
-               (yas-minor-mode nil))
-           (if args
-               (apply command-or-fn args)
-             (when (commandp command-or-fn)
-               (setq this-command command-or-fn)
-               (call-interactively command-or-fn)))))
-        (t
-         ;; also return nil if all the other fallbacks have failed
-         nil)))
-
-(defun yas--keybinding-beyond-yasnippet ()
-  "Get current keys's binding as if YASsnippet didn't exist."
-  (let* ((yas-minor-mode nil)
-         (yas--direct-keymaps nil)
-         (keys (this-single-command-keys)))
-    (or (key-binding keys t)
-        (key-binding (yas--fallback-translate-input keys) t))))
-
-(defun yas--fallback-translate-input (keys)
-  "Emulate `read-key-sequence', at least what I think it does.
-
-Keys should be an untranslated key vector.  Returns a translated
-vector of keys.  FIXME not thoroughly tested."
-  (let ((retval [])
-        (i 0))
-    (while (< i (length keys))
-      (let ((j i)
-            (translated local-function-key-map))
-        (while (and (< j (length keys))
-                    translated
-                    (keymapp translated))
-          (setq translated (cdr (assoc (aref keys j) (remove 'keymap translated)))
-                j (1+ j)))
-        (setq retval (vconcat retval (cond ((symbolp translated)
-                                            `[,translated])
-                                           ((vectorp translated)
-                                            translated)
-                                           (t
-                                            (substring keys i j)))))
-        (setq i j)))
-    retval))
-
-
-;;; Utils for snippet development:
-
-(defun yas--all-templates (tables)
-  "Get `yas--template' objects in TABLES, applicable for buffer and point.
-
-Honours `yas-choose-tables-first', `yas-choose-keys-first' and
-`yas-buffer-local-condition'"
-  (when yas-choose-tables-first
-    (setq tables (list (yas--prompt-for-table tables))))
-  (mapcar #'cdr
-          (if yas-choose-keys-first
-              (let ((key (yas--prompt-for-keys
-                          (cl-mapcan #'yas--table-all-keys tables))))
-                (when key
-                  (cl-mapcan (lambda (table)
-                               (yas--fetch table key))
-                             tables)))
-            (cl-remove-duplicates (cl-mapcan #'yas--table-templates tables)
-                                  :test #'equal))))
-
-(defun yas--lookup-snippet-1 (name mode)
-  "Get the snippet called NAME in MODE's tables."
-  (let ((yas-choose-tables-first nil)   ; avoid prompts
-        (yas-choose-keys-first nil))
-    (cl-find name (yas--all-templates
-                   (yas--get-snippet-tables mode))
-             :key #'yas--template-name :test #'string=)))
-
-(defun yas-lookup-snippet (name &optional mode noerror)
-  "Get the snippet named NAME in MODE's tables.
-
-MODE defaults to the current buffer's `major-mode'.  If NOERROR
-is non-nil, then don't signal an error if there isn't any snippet
-called NAME.
-
-Honours `yas-buffer-local-condition'."
-  (cond
-   ((yas--lookup-snippet-1 name mode))
-   (noerror nil)
-   (t (error "No snippet named: %s" name))))
-
-(defun yas-insert-snippet (&optional no-condition)
-  "Choose a snippet to expand, pop-up a list of choices according
-to `yas-prompt-functions'.
-
-With prefix argument NO-CONDITION, bypass filtering of snippets
-by condition."
-  (interactive "P")
-  (setq yas--condition-cache-timestamp (current-time))
-  (let* ((yas-buffer-local-condition (or (and no-condition
-                                              'always)
-                                         yas-buffer-local-condition))
-         (templates (yas--all-templates (yas--get-snippet-tables)))
-         (yas--current-template (and templates
-                                    (or (and (cl-rest templates) ;; more than one template for same key
-                                             (yas--prompt-for-template templates))
-                                        (car templates))))
-         (where (if (region-active-p)
-                    (cons (region-beginning) (region-end))
-                  (cons (point) (point)))))
-    (if yas--current-template
-        (yas-expand-snippet (yas--template-content yas--current-template)
-                            (car where)
-                            (cdr where)
-                            (yas--template-expand-env yas--current-template))
-      (yas--message 1 "No snippets can be inserted here!"))))
-
-(defun yas-visit-snippet-file ()
-  "Choose a snippet to edit, selection like `yas-insert-snippet'.
-
-Only success if selected snippet was loaded from a file.  Put the
-visited file in `snippet-mode'."
-  (interactive)
-  (let* ((yas-buffer-local-condition 'always)
-         (templates (yas--all-templates (yas--get-snippet-tables)))
-         (template (and templates
-                        (or (yas--prompt-for-template templates
-                                                     "Choose a snippet template to edit: ")
-                            (car templates)))))
-
-    (if template
-        (yas--visit-snippet-file-1 template)
-      (message "No snippets tables active!"))))
-
-(defun yas--visit-snippet-file-1 (template)
-  "Helper for `yas-visit-snippet-file'."
-  (let ((file (yas--template-get-file template)))
-    (cond ((and file (file-readable-p file))
-           (find-file-other-window file)
-           (snippet-mode)
-           (set (make-local-variable 'yas--editing-template) template))
-          (file
-           (message "Original file %s no longer exists!" file))
-          (t
-           (switch-to-buffer (format "*%s*"(yas--template-name template)))
-           (let ((type 'snippet))
-             (when (listp (yas--template-content template))
-               (insert (format "# type: command\n"))
-               (setq type 'command))
-             (insert (format "# key: %s\n" (yas--template-key template)))
-             (insert (format "# name: %s\n" (yas--template-name template)))
-             (when (yas--template-keybinding template)
-               (insert (format "# binding: %s\n" (yas--template-keybinding template))))
-             (when (yas--template-expand-env template)
-               (insert (format "# expand-env: %s\n" (yas--template-expand-env template))))
-             (when (yas--template-condition template)
-               (insert (format "# condition: %s\n" (yas--template-condition template))))
-             (insert "# --\n")
-             (insert (if (eq type 'command)
-                         (pp-to-string (yas--template-content template))
-                       (yas--template-content template))))
-           (snippet-mode)
-           (set (make-local-variable 'yas--editing-template) template)
-           (set (make-local-variable 'default-directory)
-                (car (cdr (car (yas--guess-snippet-directories (yas--template-table template))))))))))
-
-(defun yas--guess-snippet-directories-1 (table)
-  "Guess possible snippet subdirectories for TABLE."
-  (cons (file-name-as-directory (yas--table-name table))
-        (cl-mapcan #'yas--guess-snippet-directories-1
-                   (yas--table-parents table))))
-
-(defun yas--guess-snippet-directories (&optional table)
-  "Try to guess suitable directories based on the current active
-tables (or optional TABLE).
-
-Returns a list of elements (TABLE . DIRS) where TABLE is a
-`yas--table' object and DIRS is a list of all possible directories
-where snippets of table might exist."
-  (let ((main-dir (car (or (yas-snippet-dirs)
-                           (setq yas-snippet-dirs
-                                 (list yas--default-user-snippets-dir)))))
-        (tables (if table (list table)
-                  (yas--get-snippet-tables))))
-    ;; HACK! the snippet table created here is actually registered!
-    (unless table
-      ;; The major mode is probably the best guess, put it first.
-      (let ((major-mode-table (yas--table-get-create major-mode)))
-        (cl-callf2 delq major-mode-table tables)
-        (push major-mode-table tables)))
-
-    (mapcar #'(lambda (table)
-                (cons table
-                      (mapcar #'(lambda (subdir)
-                                  (expand-file-name subdir main-dir))
-                              (yas--guess-snippet-directories-1 table))))
-            tables)))
-
-(defun yas--make-directory-maybe (table-and-dirs &optional main-table-string)
-  "Return a dir inside TABLE-AND-DIRS, prompts for creation if none exists."
-  (or (cl-some (lambda (dir) (when (file-directory-p dir) dir))
-               (cdr table-and-dirs))
-      (let ((candidate (cl-first (cdr table-and-dirs))))
-        (unless (file-writable-p (file-name-directory candidate))
-          (error (yas--format "%s is not writable." candidate)))
-        (if (y-or-n-p (format "Guessed directory (%s) for%s%s table \"%s\" does not exist! Create? "
-                              candidate
-                              (if (gethash (yas--table-mode (car table-and-dirs))
-                                           yas--tables)
-                                  ""
-                                " brand new")
-                              (or main-table-string
-                                  "")
-                              (yas--table-name (car table-and-dirs))))
-            (progn
-              (make-directory candidate 'also-make-parents)
-              ;; create the .yas-parents file here...
-              candidate)))))
-
-;; NOTE: Using the traditional "*new snippet*" stops whitespace mode
-;; from activating (it doesn't like the leading "*").
-(defconst yas-new-snippet-buffer-name "+new-snippet+")
-
-(defun yas-new-snippet (&optional no-template)
-  "Pops a new buffer for writing a snippet.
-
-Expands a snippet-writing snippet, unless the optional prefix arg
-NO-TEMPLATE is non-nil."
-  (interactive "P")
-  (let ((guessed-directories (yas--guess-snippet-directories))
-        (yas-selected-text (or yas-selected-text
-                               (and (region-active-p)
-                                    (buffer-substring-no-properties
-                                     (region-beginning) (region-end))))))
-
-    (switch-to-buffer yas-new-snippet-buffer-name)
-    (erase-buffer)
-    (kill-all-local-variables)
-    (snippet-mode)
-    (yas-minor-mode 1)
-    (set (make-local-variable 'yas--guessed-modes)
-         (mapcar (lambda (d) (yas--table-mode (car d)))
-                 guessed-directories))
-    (set (make-local-variable 'default-directory)
-         (car (cdr (car guessed-directories))))
-    (if (and (not no-template) yas-new-snippet-default)
-        (yas-expand-snippet yas-new-snippet-default))))
-
-(defun yas--compute-major-mode-and-parents (file)
-  "Given FILE, find the nearest snippet directory for a given mode.
-
-Returns a list (MODE-SYM PARENTS), the mode's symbol and a list
-representing one or more of the mode's parents.
-
-Note that MODE-SYM need not be the symbol of a real major mode,
-neither do the elements of PARENTS."
-  (let* ((file-dir (and file
-                        (directory-file-name
-                         (or (cl-some (lambda (special)
-                                        (locate-dominating-file file special))
-                                      '(".yas-setup.el"
-                                        ".yas-make-groups"
-                                        ".yas-parents"))
-                             (directory-file-name (file-name-directory file))))))
-         (parents-file-name (concat file-dir "/.yas-parents"))
-         (major-mode-name (and file-dir
-                               (file-name-nondirectory file-dir)))
-         (major-mode-sym (or (and major-mode-name
-                                  (intern major-mode-name))))
-         (parents (when (file-readable-p parents-file-name)
-                         (mapcar #'intern
-                                 (split-string
-                                  (with-temp-buffer
-                                    (insert-file-contents parents-file-name)
-                                    (buffer-substring-no-properties (point-min)
-                                                                    (point-max))))))))
-    (when major-mode-sym
-      (cons major-mode-sym (remove major-mode-sym parents)))))
-
-(defvar yas--editing-template nil
-  "Supporting variable for `yas-load-snippet-buffer' and `yas--visit-snippet'.")
-
-(defvar yas--current-template nil
-  "Holds the current template being expanded into a snippet.")
-
-(defvar yas--guessed-modes nil
-  "List of guessed modes supporting `yas-load-snippet-buffer'.")
-
-(defun yas--read-table ()
-  "Ask user for a snippet table, help with some guessing."
-  (let ((prompt (if (and (featurep 'ido)
-                         ido-mode)
-                    'ido-completing-read 'completing-read)))
-    (unless yas--guessed-modes
-      (set (make-local-variable 'yas--guessed-modes)
-           (or (yas--compute-major-mode-and-parents buffer-file-name))))
-    (intern
-     (funcall prompt (format "Choose or enter a table (yas guesses %s): "
-                             (if yas--guessed-modes
-                                 (cl-first yas--guessed-modes)
-                               "nothing"))
-              (mapcar #'symbol-name yas--guessed-modes)
-              nil
-              nil
-              nil
-              nil
-              (if (cl-first yas--guessed-modes)
-                  (symbol-name (cl-first yas--guessed-modes)))))))
-
-(defun yas-load-snippet-buffer (table &optional interactive)
-  "Parse and load current buffer's snippet definition into TABLE.
-TABLE is a symbol name passed to `yas--table-get-create'.  When
-called interactively, prompt for the table name.
-Return the `yas--template' object created"
-  (interactive (list (yas--read-table) t))
-  (cond
-   ;;  We have `yas--editing-template', this buffer's content comes from a
-   ;;  template which is already loaded and neatly positioned,...
-   ;;
-   (yas--editing-template
-    (yas--define-snippets-1 (yas--parse-template (yas--template-load-file yas--editing-template))
-                           (yas--template-table yas--editing-template)))
-   ;; Try to use `yas--guessed-modes'. If we don't have that use the
-   ;; value from `yas--compute-major-mode-and-parents'
-   ;;
-   (t
-    (unless yas--guessed-modes
-      (set (make-local-variable 'yas--guessed-modes) (or (yas--compute-major-mode-and-parents buffer-file-name))))
-    (let* ((table (yas--table-get-create table)))
-      (set (make-local-variable 'yas--editing-template)
-           (yas--define-snippets-1 (yas--parse-template buffer-file-name)
-                                  table)))))
-  (when interactive
-    (yas--message 3 "Snippet \"%s\" loaded for %s."
-                  (yas--template-name yas--editing-template)
-                  (yas--table-name (yas--template-table yas--editing-template))))
-  yas--editing-template)
-
-(defun yas-maybe-load-snippet-buffer ()
-  "Added to `after-save-hook' in `snippet-mode'."
-  (let* ((mode (intern (file-name-sans-extension
-                        (file-name-nondirectory
-                         (directory-file-name default-directory)))))
-         (current-snippet
-          (apply #'yas--define-snippets-2 (yas--table-get-create mode)
-                 (yas--parse-template buffer-file-name)))
-         (uuid (yas--template-uuid current-snippet)))
-    (unless (equal current-snippet
-                   (if uuid (yas--get-template-by-uuid mode uuid)
-                     (yas--lookup-snippet-1
-                      (yas--template-name current-snippet) mode)))
-      (yas-load-snippet-buffer mode t))))
-
-(defun yas-load-snippet-buffer-and-close (table &optional kill)
-  "Load and save the snippet, then `quit-window' if saved.
-Loading is performed by `yas-load-snippet-buffer'.  If the
-snippet is new, ask the user whether (and where) to save it.  If
-the snippet already has a file, just save it.
-
-The prefix argument KILL is passed to `quit-window'.
-
-Don't use this from a Lisp program, call `yas-load-snippet-buffer'
-and `kill-buffer' instead."
-  (interactive (list (yas--read-table) current-prefix-arg))
-  (let ((template (yas-load-snippet-buffer table t)))
-    (when (and (buffer-modified-p)
-               (y-or-n-p
-                (format "[yas] Loaded for %s. Also save snippet buffer?"
-                        (yas--table-name (yas--template-table template)))))
-      (let ((default-directory (car (cdr (car (yas--guess-snippet-directories
-                                               (yas--template-table template))))))
-            (default-file-name (yas--template-name template)))
-        (unless (or buffer-file-name (not default-file-name))
-          (setq buffer-file-name
-                (read-file-name "File to save snippet in: "
-                                nil nil nil default-file-name))
-          (rename-buffer (file-name-nondirectory buffer-file-name) t))
-        (save-buffer)))
-    (quit-window kill)))
-
-(declare-function yas-debug-snippets "yasnippet-debug")
-
-(defun yas-tryout-snippet (&optional debug)
-  "Test current buffer's snippet template in other buffer.
-DEBUG is for debugging the YASnippet engine itself."
-  (interactive "P")
-  (let* ((major-mode-and-parent (yas--compute-major-mode-and-parents buffer-file-name))
-         (parsed (yas--parse-template))
-         (test-mode (or (and (car major-mode-and-parent)
-                             (fboundp (car major-mode-and-parent))
-                             (car major-mode-and-parent))
-                        (cl-first yas--guessed-modes)
-                        (intern (read-from-minibuffer (yas--format "Please input a mode: ")))))
-         (yas--current-template
-          (and parsed
-               (fboundp test-mode)
-               (yas--make-template :table       nil ;; no tables for ephemeral snippets
-                                   :key         (nth 0 parsed)
-                                   :content     (nth 1 parsed)
-                                   :name        (nth 2 parsed)
-                                   :expand-env  (nth 5 parsed)))))
-    (cond (yas--current-template
-           (let ((buffer-name (format "*testing snippet: %s*" (yas--template-name yas--current-template))))
-             (kill-buffer (get-buffer-create buffer-name))
-             (switch-to-buffer (get-buffer-create buffer-name))
-             (setq buffer-undo-list nil)
-             (condition-case nil (funcall test-mode) (error nil))
-	     (yas-minor-mode 1)
-             (setq buffer-read-only nil)
-             (yas-expand-snippet (yas--template-content yas--current-template)
-                                 (point-min)
-                                 (point-max)
-                                 (yas--template-expand-env yas--current-template))
-             (when (and debug
-                        (require 'yasnippet-debug nil t))
-               (yas-debug-snippets "*YASnippet trace*" 'snippet-navigation)
-               (display-buffer "*YASnippet trace*"))))
-          (t
-           (yas--message 1 "Cannot test snippet for unknown major mode")))))
-
-(defun yas-active-keys ()
-  "Return all active trigger keys for current buffer and point."
-  (cl-remove-duplicates
-   (cl-remove-if-not #'stringp (cl-mapcan #'yas--table-all-keys
-                                          (yas--get-snippet-tables)))
-   :test #'string=))
-
-(defun yas--template-fine-group (template)
-  (car (last (or (yas--template-group template)
-                 (yas--template-perm-group template)))))
-
-(defun yas-describe-table-by-namehash ()
-  "Display snippet tables by NAMEHASH."
-  (interactive)
-  (with-current-buffer (get-buffer-create "*YASnippet Tables by NAMEHASH*")
-    (let ((inhibit-read-only t))
-      (erase-buffer)
-      (insert "YASnippet tables by NAMEHASH: \n")
-      (maphash
-       (lambda (_mode table)
-         (insert (format "\nSnippet table `%s':\n\n" (yas--table-name table)))
-         (maphash
-          (lambda (key _v)
-            (insert (format "   key %s maps snippets: %s\n" key
-                            (let ((names))
-                              (maphash #'(lambda (k _v)
-                                           (push k names))
-                                       (gethash key (yas--table-hash table)))
-                              names))))
-          (yas--table-hash table)))
-       yas--tables))
-    (view-mode +1)
-    (goto-char 1)
-    (display-buffer (current-buffer))))
-
-(defun yas-describe-tables (&optional with-nonactive)
-  "Display snippets for each table."
-  (interactive "P")
-  (let ((original-buffer (current-buffer))
-        (tables (yas--get-snippet-tables)))
-   (with-current-buffer (get-buffer-create "*YASnippet Tables*")
-     (let ((inhibit-read-only t))
-       (when with-nonactive
-         (maphash #'(lambda (_k v)
-                      (cl-pushnew v tables))
-                  yas--tables))
-       (erase-buffer)
-       (insert "YASnippet tables:\n")
-       (dolist (table tables)
-         (yas--describe-pretty-table table original-buffer))
-       (yas--create-snippet-xrefs))
-     (help-mode)
-     (goto-char 1)
-     (display-buffer (current-buffer)))))
-
-(defun yas--describe-pretty-table (table &optional original-buffer)
-  (insert (format "\nSnippet table `%s'"
-                  (yas--table-name table)))
-  (if (yas--table-parents table)
-      (insert (format " parents: %s\n"
-                      (mapcar #'yas--table-name
-                              (yas--table-parents table))))
-    (insert "\n"))
-  (insert (make-string 100 ?-) "\n")
-  (insert "group                   state name                                    key             binding\n")
-  (let ((groups-hash (make-hash-table :test #'equal)))
-    (maphash #'(lambda (_k v)
-                 (let ((group (or (yas--template-fine-group v)
-                                  "(top level)")))
-                   (when (yas--template-name v)
-                     (puthash group
-                              (cons v (gethash group groups-hash))
-                              groups-hash))))
-             (yas--table-uuidhash table))
-    (maphash
-     #'(lambda (group templates)
-         (setq group (truncate-string-to-width group 25 0 ?  "..."))
-         (insert (make-string 100 ?-) "\n")
-         (dolist (p templates)
-           (let* ((name (truncate-string-to-width (propertize (format "\\\\snippet `%s'" (yas--template-name p))
-                                                              'yasnippet p)
-                                                  50 0 ? "..."))
-                  (group (prog1 group
-                           (setq group (make-string (length group) ? ))))
-                  (condition-string (let ((condition (yas--template-condition p)))
-                                      (if (and condition
-                                               original-buffer)
-                                          (with-current-buffer original-buffer
-                                            (if (yas--eval-condition condition)
-                                                "(y)"
-                                              "(s)"))
-                                        "(a)")))
-                  (key-description-string (key-description (yas--template-keybinding p)))
-                  (template-key-padding (if (string= key-description-string "") nil ? )))
-             (insert group " "
-                     condition-string " "
-                     name (if (string-match "\\.\\.\\.$" name)
-                              "'" " ")
-                     " "
-                     (truncate-string-to-width (or (yas--template-key p) "")
-                                               15 0 template-key-padding "...")
-                     (or template-key-padding "")
-                     (truncate-string-to-width key-description-string
-                                               15 0 nil "...")
-                     "\n"))))
-     groups-hash)))
-
-
-
-;;; User convenience functions, for using in `yas-key-syntaxes'
-
-(defun yas-try-key-from-whitespace (_start-point)
-  "As `yas-key-syntaxes' element, look for whitespace delimited key.
-
-A newline will be considered whitespace even if the mode syntax
-marks it as something else (typically comment ender)."
-  (skip-chars-backward "^[:space:]\n"))
-
-(defun yas-shortest-key-until-whitespace (_start-point)
-  "Like `yas-longest-key-from-whitespace' but take the shortest key."
-  (when (/= (skip-chars-backward "^[:space:]\n" (1- (point))) 0)
-    'again))
-
-(defun yas-longest-key-from-whitespace (start-point)
-  "As `yas-key-syntaxes' element, look for longest key between point and whitespace.
-
-A newline will be considered whitespace even if the mode syntax
-marks it as something else (typically comment ender)."
-  (if (= (point) start-point)
-      (yas-try-key-from-whitespace start-point)
-    (forward-char))
-  (unless (<= start-point (1+ (point)))
-    'again))
-
-
-
-;;; User convenience functions, for using in snippet definitions
-
-(defvar yas-modified-p nil
-  "Non-nil if field has been modified by user or transformation.")
-
-(defvar yas-moving-away-p nil
-  "Non-nil if user is about to exit field.")
-
-(defvar yas-text nil
-  "Contains current field text.")
-
-(defun yas-substr (str pattern &optional subexp)
-  "Search PATTERN in STR and return SUBEXPth match.
-
-If found, the content of subexp group SUBEXP (default 0) is
-  returned, or else the original STR will be returned."
-  (let ((grp (or subexp 0)))
-    (save-match-data
-      (if (string-match pattern str)
-          (match-string-no-properties grp str)
-        str))))
-
-(defun yas-choose-value (&rest possibilities)
-  "Prompt for a string in POSSIBILITIES and return it.
-
-The last element of POSSIBILITIES may be a list of strings."
-  (unless (or yas-moving-away-p
-              yas-modified-p)
-    (let* ((last-link (last possibilities))
-           (last-elem (car last-link)))
-      (when (listp last-elem)
-        (setcar last-link (car last-elem))
-        (setcdr last-link (cdr last-elem))))
-    (cl-some (lambda (fn)
-               (funcall fn "Choose: " possibilities))
-             yas-prompt-functions)))
-
-(defun yas--auto-next ()
-  "Helper for `yas-auto-next'."
-  (remove-hook 'post-command-hook #'yas--auto-next t)
-  (yas-next-field))
-
-(defmacro yas-auto-next (&rest body)
-  "Automatically advance to next field after eval'ing BODY."
-  (declare (indent 0) (debug t))
-  `(unless yas-moving-away-p
-     (prog1 ,@body
-       (add-hook 'post-command-hook #'yas--auto-next nil t))))
-
-(defun yas-key-to-value (alist)
-  (unless (or yas-moving-away-p
-              yas-modified-p)
-    (let ((key (read-key-sequence "")))
-      (when (stringp key)
-        (or (cdr (cl-find key alist :key #'car :test #'string=))
-            key)))))
-
-(defun yas-throw (text)
-  "Signal `yas-exception' with TEXT as the reason."
-  (signal 'yas-exception (list text)))
-(put 'yas-exception 'error-conditions '(error yas-exception))
-(put 'yas-exception 'error-message "[yas] Exception")
-
-(defun yas-verify-value (possibilities)
-  "Verify that the current field value is in POSSIBILITIES.
-Otherwise signal `yas-exception'."
-  (when (and yas-moving-away-p (cl-notany (lambda (pos) (string= pos yas-text)) possibilities))
-    (yas-throw (format "Field only allows %s" possibilities))))
-
-(defun yas-field-value (number)
-  "Get the string for field with NUMBER.
-
-Use this in primary and mirror transformations to get the text of
-other fields."
-  (let* ((snippet (car (yas-active-snippets)))
-         (field (and snippet
-                     (yas--snippet-find-field snippet number))))
-    (when field
-      (yas--field-text-for-display field))))
-
-(defun yas-text ()
-  "Return `yas-text' if that exists and is non-empty, else nil."
-  (if (and yas-text
-           (not (string= "" yas-text)))
-      yas-text))
-
-(defun yas-selected-text ()
-  "Return `yas-selected-text' if that exists and is non-empty, else nil."
-  (if (and yas-selected-text
-           (not (string= "" yas-selected-text)))
-      yas-selected-text))
-
-(defun yas--get-field-once (number &optional transform-fn)
-  (unless yas-modified-p
-    (if transform-fn
-        (funcall transform-fn (yas-field-value number))
-      (yas-field-value number))))
-
-(defun yas-default-from-field (number)
-  (unless yas-modified-p
-    (yas-field-value number)))
-
-(defun yas-inside-string ()
-  "Return non-nil if the point is inside a string according to font-lock."
-  (equal 'font-lock-string-face (get-char-property (1- (point)) 'face)))
-
-(defun yas-unimplemented (&optional missing-feature)
-  (if yas--current-template
-      (if (y-or-n-p (format "This snippet is unimplemented (missing %s) Visit the snippet definition? "
-                            (or missing-feature
-                                "something")))
-          (yas--visit-snippet-file-1 yas--current-template))
-    (message "No implementation. Missing %s" (or missing-feature "something"))))
-
-
-;;; Snippet expansion and field management
-
-(defvar yas--active-field-overlay nil
-  "Overlays the currently active field.")
-
-(defvar yas--active-snippets nil
-  "List of currently active snippets")
-(make-variable-buffer-local 'yas--active-snippets)
-
-(defvar yas--field-protection-overlays nil
-  "Two overlays protect the current active field.")
-
-(defvar yas-selected-text nil
-  "The selected region deleted on the last snippet expansion.")
-
-(defvar yas--start-column nil
-  "The column where the snippet expansion started.")
-
-(make-variable-buffer-local 'yas--active-field-overlay)
-(make-variable-buffer-local 'yas--field-protection-overlays)
-(put 'yas--active-field-overlay 'permanent-local t)
-(put 'yas--field-protection-overlays 'permanent-local t)
-
-(cl-defstruct (yas--snippet (:constructor yas--make-snippet (expand-env)))
-  "A snippet.
-
-..."
-  expand-env
-  (fields '())
-  (exit nil)
-  (id (yas--snippet-next-id) :read-only t)
-  (control-overlay nil)
-  active-field
-  ;; stacked expansion: the `previous-active-field' slot saves the
-  ;; active field where the child expansion took place
-  previous-active-field
-  force-exit)
-
-(cl-defstruct (yas--field (:constructor yas--make-field (number start end parent-field)))
-  "A field.
-
-NUMBER is the field number.
-START and END are mostly buffer markers, but see \"apropos markers-to-points\".
-PARENT-FIELD is a `yas--field' this field is nested under, or nil.
-MIRRORS is a list of `yas--mirror's
-TRANSFORM is a lisp form.
-MODIFIED-P is a boolean set to true once user inputs text.
-NEXT is another `yas--field' or `yas--mirror' or `yas--exit'.
-"
-  number
-  start end
-  parent-field
-  (mirrors '())
-  (transform nil)
-  (modified-p nil)
-  next)
-
-
-(cl-defstruct (yas--mirror (:constructor yas--make-mirror (start end transform)))
-  "A mirror.
-
-START and END are mostly buffer markers, but see \"apropos markers-to-points\".
-TRANSFORM is a lisp form.
-PARENT-FIELD is a `yas--field' this mirror is nested under, or nil.
-NEXT is another `yas--field' or `yas--mirror' or `yas--exit'
-DEPTH is a count of how many nested mirrors can affect this mirror"
-  start end
-  (transform nil)
-  parent-field
-  next
-  depth)
-
-(cl-defstruct (yas--exit (:constructor yas--make-exit (marker)))
-  marker
-  next)
-
-(defmacro yas--letenv (env &rest body)
-  "Evaluate BODY with bindings from ENV.
-ENV is a lisp expression that evaluates to list of elements with
-the form (VAR FORM), where VAR is a symbol and FORM is a lisp
-expression that evaluates to its value."
-  (declare (debug (form body)) (indent 1))
-  (let ((envvar (make-symbol "envvar")))
-    `(let ((,envvar ,env))
-       (cl-progv
-           (mapcar #'car ,envvar)
-           (mapcar (lambda (v-f) (eval (cadr v-f))) ,envvar)
-         ,@body))))
-
-(defun yas--snippet-map-markers (fun snippet)
-  "Apply FUN to all marker (sub)fields in SNIPPET.
-Update each field with the result of calling FUN."
-  (dolist (field (yas--snippet-fields snippet))
-    (setf (yas--field-start field) (funcall fun (yas--field-start field)))
-    (setf (yas--field-end field)   (funcall fun (yas--field-end field)))
-    (dolist (mirror (yas--field-mirrors field))
-      (setf (yas--mirror-start mirror) (funcall fun (yas--mirror-start mirror)))
-      (setf (yas--mirror-end mirror)   (funcall fun (yas--mirror-end mirror)))))
-  (let ((snippet-exit (yas--snippet-exit snippet)))
-    (when snippet-exit
-      (setf (yas--exit-marker snippet-exit)
-            (funcall fun (yas--exit-marker snippet-exit))))))
-
-(defun yas--snippet-live-p (snippet)
-  "Return non-nil if SNIPPET hasn't been committed."
-  (catch 'live
-    (yas--snippet-map-markers (lambda (m)
-                                (if (markerp m) m
-                                  (throw 'live nil)))
-                              snippet)
-    t))
-
-(defun yas--apply-transform (field-or-mirror field &optional empty-on-nil-p)
-  "Calculate transformed string for FIELD-OR-MIRROR from FIELD.
-
-If there is no transform for ht field, return nil.
-
-If there is a transform but it returns nil, return the empty
-string iff EMPTY-ON-NIL-P is true."
-  (let* ((yas-text (yas--field-text-for-display field))
-         (yas-modified-p (yas--field-modified-p field))
-         (transform (if (yas--mirror-p field-or-mirror)
-                        (yas--mirror-transform field-or-mirror)
-                      (yas--field-transform field-or-mirror)))
-         (start-point (if (yas--mirror-p field-or-mirror)
-                          (yas--mirror-start field-or-mirror)
-                        (yas--field-start field-or-mirror)))
-         (transformed (and transform
-                           (save-excursion
-                             (goto-char start-point)
-                             (let ((ret (yas--eval-for-string transform)))
-                               (or ret (and empty-on-nil-p "")))))))
-    transformed))
-
-(defsubst yas--replace-all (from to &optional text)
-  "Replace all occurrences from FROM to TO.
-
-With optional string TEXT do it in that string."
-  (if text
-      (replace-regexp-in-string (regexp-quote from) to text t t)
-    (goto-char (point-min))
-    (while (search-forward from nil t)
-      (replace-match to t t text))))
-
-(defun yas--snippet-find-field (snippet number)
-  (cl-find-if (lambda (field)
-                (eq number (yas--field-number field)))
-              (yas--snippet-fields snippet)))
-
-(defun yas--snippet-sort-fields (snippet)
-  "Sort the fields of SNIPPET in navigation order."
-  (setf (yas--snippet-fields snippet)
-        (sort (yas--snippet-fields snippet)
-              #'yas--snippet-field-compare)))
-
-(defun yas--snippet-field-compare (field1 field2)
-  "Compare FIELD1 and FIELD2.
-
-The field with a number is sorted first.  If they both have a
-number, compare through the number.  If neither have, compare
-through the field's start point"
-  (let ((n1 (yas--field-number field1))
-        (n2 (yas--field-number field2)))
-    (if n1
-        (if n2
-            (or (zerop n2) (and (not (zerop n1))
-                                (< n1 n2)))
-          (not (zerop n1)))
-      (if n2
-          (zerop n2)
-        (< (yas--field-start field1)
-           (yas--field-start field2))))))
-
-(defun yas--field-probably-deleted-p (snippet field)
-  "Guess if SNIPPET's FIELD should be skipped."
-  (and
-   ;; field must be zero length
-   ;;
-   (zerop (- (yas--field-start field) (yas--field-end field)))
-   ;; field must have been modified
-   ;;
-   (yas--field-modified-p field)
-   ;; either:
-   (or
-    ;;  1) it's a nested field
-    ;;
-    (yas--field-parent-field field)
-    ;;  2) ends just before the snippet end
-    ;;
-    (and (eq field (car (last (yas--snippet-fields snippet))))
-         (= (yas--field-start field) (overlay-end (yas--snippet-control-overlay snippet)))))
-   ;; the field numbered 0, just before the exit marker, should
-   ;; never be skipped
-   ;;
-   (not (and (yas--field-number field)
-             (zerop (yas--field-number field))))))
-
-(defun yas-active-snippets (&optional beg end)
-  "Return a sorted list of active snippets.
-The most recently-inserted snippets are returned first.
-
-Only snippets overlapping the region BEG ... END are returned.
-Overlapping has the same meaning as described in `overlays-in'.
-If END is omitted, it defaults to (1+ BEG).  If BEG is omitted,
-it defaults to point.  A non-nil, non-buffer position BEG is
-equivalent to a range covering the whole buffer."
-  (unless beg
-    (setq beg (point)))
-  (cond ((not (or (integerp beg) (markerp beg)))
-         (setq beg (point-min) end (point-max)))
-        ((not end)
-         (setq end (1+ beg))))
-  (if (and (eq beg (point-min))
-           (eq end (point-max)))
-      yas--active-snippets
-    ;; Note: don't use `mapcar' here, since it would allocate in
-    ;; proportion to the amount of overlays, even though the list of
-    ;; active snippets should be very small.
-    (let ((snippets nil))
-      (dolist (ov (overlays-in beg end))
-        (let ((snippet (overlay-get ov 'yas--snippet)))
-          ;; Snippets have multiple overlays, so check for dups.
-          (when (and snippet (not (memq snippet snippets)))
-            (push snippet snippets))))
-      (cl-sort snippets #'>= :key #'yas--snippet-id))))
-
-(define-obsolete-function-alias 'yas--snippets-at-point
-  'yas-active-snippets "0.12")
-
-(defun yas-next-field-or-maybe-expand ()
-  "Try to expand a snippet at a key before point.
-
-Otherwise delegate to `yas-next-field'."
-  (interactive)
-  (if yas-triggers-in-field
-      (let ((yas-fallback-behavior 'return-nil)
-            (active-field (overlay-get yas--active-field-overlay 'yas--field)))
-        (when active-field
-          (unless (yas-expand-from-trigger-key active-field)
-            (yas-next-field))))
-    (yas-next-field)))
-
-(defun yas-next-field-will-exit-p (&optional arg)
-  "Return non-nil if (yas-next-field ARG) would exit the current snippet."
-  (let ((snippet (car (yas-active-snippets)))
-        (active (overlay-get yas--active-field-overlay 'yas--field)))
-    (when snippet
-      (not (yas--find-next-field arg snippet active)))))
-
-(defun yas--find-next-field (n snippet active)
-  "Return the Nth field after the ACTIVE one in SNIPPET."
-  (let ((live-fields (cl-remove-if
-                      (lambda (field)
-                        (and (not (eq field active))
-                             (yas--field-probably-deleted-p snippet field)))
-                      (yas--snippet-fields snippet))))
-    (nth (abs n) (memq active (if (>= n 0) live-fields (reverse live-fields))))))
-
-(defun yas-next-field (&optional arg)
-  "Navigate to the ARGth next field.
-
-If there's none, exit the snippet."
-  (interactive)
-  (unless arg (setq arg 1))
-  (let* ((snippet (car (yas-active-snippets)))
-         (active-field (overlay-get yas--active-field-overlay 'yas--field))
-         (target-field (yas--find-next-field arg snippet active-field)))
-    (yas--letenv (yas--snippet-expand-env snippet)
-      ;; Apply transform to active field.
-      (when active-field
-        (let ((yas-moving-away-p t))
-          (when (yas--field-update-display active-field)
-            (yas--update-mirrors snippet))))
-      ;; Now actually move...
-      (if target-field
-          (yas--move-to-field snippet target-field)
-        (yas-exit-snippet snippet)))))
-
-(defun yas--place-overlays (snippet field)
-  "Correctly place overlays for SNIPPET's FIELD."
-  (yas--make-move-field-protection-overlays snippet field)
-  ;; Only move active field overlays if this is field is from the
-  ;; innermost snippet.
-  (when (eq snippet (car (yas-active-snippets (1- (yas--field-start field))
-                                              (1+ (yas--field-end field)))))
-    (yas--make-move-active-field-overlay snippet field)))
-
-(defun yas--move-to-field (snippet field)
-  "Update SNIPPET to move to field FIELD.
-
-Also create some protection overlays"
-  (goto-char (yas--field-start field))
-  (yas--place-overlays snippet field)
-  (overlay-put yas--active-field-overlay 'yas--snippet snippet)
-  (overlay-put yas--active-field-overlay 'yas--field field)
-  (let ((number (yas--field-number field)))
-    ;; check for the special ${0: ...} field
-    (if (and number (zerop number))
-        (progn
-          (set-mark (yas--field-end field))
-          (setf (yas--snippet-force-exit snippet)
-                (or (yas--field-transform field)
-                    t)))
-      ;; make this field active
-      (setf (yas--snippet-active-field snippet) field)
-      ;; primary field transform: first call to snippet transform
-      (unless (yas--field-modified-p field)
-        (if (yas--field-update-display field)
-            (yas--update-mirrors snippet)
-          (setf (yas--field-modified-p field) nil))))))
-
-(defun yas-prev-field ()
-  "Navigate to prev field.  If there's none, exit the snippet."
-  (interactive)
-  (yas-next-field -1))
-
-(defun yas-abort-snippet (&optional snippet)
-  (interactive)
-  (let ((snippet (or snippet
-                     (car (yas-active-snippets)))))
-    (when snippet
-      (setf (yas--snippet-force-exit snippet) t))))
-
-(defun yas-exit-snippet (snippet)
-  "Goto exit-marker of SNIPPET."
-  (interactive (list (cl-first (yas-active-snippets))))
-  (when snippet
-    (setf (yas--snippet-force-exit snippet) t)
-    (goto-char (if (yas--snippet-exit snippet)
-                   (yas--exit-marker (yas--snippet-exit snippet))
-                 (overlay-end (yas--snippet-control-overlay snippet))))))
-
-(defun yas-exit-all-snippets ()
-  "Exit all snippets."
-  (interactive)
-  (mapc #'(lambda (snippet)
-            (yas-exit-snippet snippet)
-            (yas--check-commit-snippet))
-        (yas-active-snippets 'all)))
-
-
-;;; Some low level snippet-routines:
-
-(defvar yas--inhibit-overlay-hooks nil
-  "Bind this temporarily to non-nil to prevent running `yas--on-*-modification'.")
-
-(defvar yas-snippet-beg nil "Beginning position of the last snippet committed.")
-(defvar yas-snippet-end nil "End position of the last snippet committed.")
-
-(defun yas--commit-snippet (snippet)
-  "Commit SNIPPET, but leave point as it is.
-
-This renders the snippet as ordinary text."
-
-  (let ((control-overlay (yas--snippet-control-overlay snippet)))
-    ;;
-    ;; Save the end of the moribund snippet in case we need to revive it
-    ;; its original expansion.
-    ;;
-    (when (and control-overlay
-               (overlay-buffer control-overlay))
-      (setq yas-snippet-beg (overlay-start control-overlay))
-      (setq yas-snippet-end (overlay-end control-overlay))
-      (delete-overlay control-overlay)
-      (setf (yas--snippet-control-overlay snippet) nil))
-
-    (let ((yas--inhibit-overlay-hooks t))
-      (when yas--active-field-overlay
-        (delete-overlay yas--active-field-overlay))
-      (when yas--field-protection-overlays
-        (mapc #'delete-overlay yas--field-protection-overlays)))
-
-    ;; stacked expansion: if the original expansion took place from a
-    ;; field, make sure we advance it here at least to
-    ;; `yas-snippet-end'...
-    ;;
-    (let ((previous-field (yas--snippet-previous-active-field snippet)))
-      (when (and yas-snippet-end previous-field)
-        (yas--advance-end-maybe previous-field yas-snippet-end)))
-
-    ;; Convert all markers to points,
-    ;;
-    (yas--markers-to-points snippet)
-
-    ;; It's no longer an active snippet.
-    (cl-callf2 delq snippet yas--active-snippets)
-
-    ;; Take care of snippet revival on undo.
-    (if (and yas-snippet-revival (listp buffer-undo-list))
-        (push `(apply yas--snippet-revive ,yas-snippet-beg ,yas-snippet-end ,snippet)
-              buffer-undo-list)
-      ;; Dismember the snippet... this is useful if we get called
-      ;; again from `yas--take-care-of-redo'....
-      (setf (yas--snippet-fields snippet) nil)))
-
-  (yas--message 4 "Snippet %s exited." (yas--snippet-id snippet)))
-
-(defvar yas--snippets-to-move nil)
-(make-variable-buffer-local 'yas--snippets-to-move)
-
-(defun yas--prepare-snippets-for-move (beg end buf pos)
-  "Gather snippets in BEG..END for moving to POS in BUF."
-  (let ((to-move nil)
-        (snippets (yas-active-snippets beg end))
-        (dst-base-line (with-current-buffer buf
-                         (count-lines (point-min) pos))))
-    (when snippets
-      (dolist (snippet snippets)
-        (yas--snippet-map-markers
-         (lambda (m)
-           (goto-char m)
-           (beginning-of-line)
-           (prog1 (cons (count-lines (point-min) (point))
-                        (yas--snapshot-marker-location m))
-             (set-marker m nil)))
-         snippet)
-        (let ((ctrl-ov (yas--snapshot-overlay-line-location
-                        (yas--snippet-control-overlay snippet))))
-          (push (list ctrl-ov dst-base-line snippet) to-move)
-          (delete-overlay (car ctrl-ov))))
-      (with-current-buffer buf
-        (setq yas--snippets-to-move (nconc to-move yas--snippets-to-move))))))
-
-(defun yas--on-buffer-kill ()
-  ;; Org mode uses temp buffers for fontification and "native tab",
-  ;; move all the snippets to the original org-mode buffer when it's
-  ;; killed.
-  (let ((org-marker nil))
-    (when (and yas-minor-mode
-               (or (bound-and-true-p org-edit-src-from-org-mode)
-                   (bound-and-true-p org-src--from-org-mode))
-               (markerp
-                (setq org-marker
-                      (or (bound-and-true-p org-edit-src-beg-marker)
-                          (bound-and-true-p org-src--beg-marker)))))
-      (yas--prepare-snippets-for-move
-       (point-min) (point-max)
-       (marker-buffer org-marker) org-marker))))
-
-(add-hook 'kill-buffer-hook #'yas--on-buffer-kill)
-
-(defun yas--finish-moving-snippets ()
-  "Finish job started in `yas--prepare-snippets-for-move'."
-  (cl-loop for (ctrl-ov base-line snippet) in yas--snippets-to-move
-           for base-pos = (progn (goto-char (point-min))
-                                 (forward-line base-line) (point))
-           do (yas--snippet-map-markers
-               (lambda (l-m-r-w)
-                 (goto-char base-pos)
-                 (forward-line (nth 0 l-m-r-w))
-                 (save-restriction
-                   (narrow-to-region (line-beginning-position)
-                                     (line-end-position))
-                   (yas--restore-marker-location (cdr l-m-r-w)))
-                 (nth 1 l-m-r-w))
-               snippet)
-           (goto-char base-pos)
-           (yas--restore-overlay-location ctrl-ov)
-           (yas--maybe-move-to-active-field snippet))
-  (setq yas--snippets-to-move nil))
-
-(defun yas--safely-call-fun (fun)
-  "Call FUN and catch any errors."
-  (condition-case error
-      (funcall fun)
-    ((debug error)
-     (yas--message 2 "Error running %s: %s" fun
-                   (error-message-string error)))))
-
-(defun yas--safely-run-hook (hook)
-  "Call HOOK's functions.
-HOOK should be a symbol, a hook variable, as in `run-hooks'."
-  (let ((debug-on-error (and (not (memq yas-good-grace '(t hooks)))
-                             debug-on-error)))
-    (yas--safely-call-fun (apply-partially #'run-hooks hook))))
-
-(defun yas--check-commit-snippet ()
-  "Check if point exited the currently active field of the snippet.
-
-If so cleans up the whole snippet up."
-  (let* ((snippet-exit-transform nil)
-         (exited-snippets-p nil)
-         ;; Record the custom snippet `yas-after-exit-snippet-hook'
-         ;; set in the expand-env field.
-         (snippet-exit-hook yas-after-exit-snippet-hook))
-    (dolist (snippet yas--active-snippets)
-      (let ((active-field (yas--snippet-active-field snippet)))
-        (yas--letenv (yas--snippet-expand-env snippet)
-          ;; Note: the `force-exit' field could be a transform in case of
-          ;; ${0: ...}, see `yas--move-to-field'.
-          (setq snippet-exit-transform (yas--snippet-force-exit snippet))
-          (cond ((or snippet-exit-transform
-                     (not (and active-field (yas--field-contains-point-p active-field))))
-                 (setf (yas--snippet-force-exit snippet) nil)
-                 (setq snippet-exit-hook yas-after-exit-snippet-hook)
-                 (yas--commit-snippet snippet)
-                 (setq exited-snippets-p t))
-                ((and active-field
-                      (or (not yas--active-field-overlay)
-                          (not (overlay-buffer yas--active-field-overlay))))
-                 ;;
-                 ;; stacked expansion: this case is mainly for recent
-                 ;; snippet exits that place us back int the field of
-                 ;; another snippet
-                 ;;
-                 (save-excursion
-                   (yas--move-to-field snippet active-field)
-                   (yas--update-mirrors snippet)))
-                (t
-                 nil)))))
-    (unless (or yas--active-snippets (not exited-snippets-p))
-      (when snippet-exit-transform
-        (yas--eval-for-effect snippet-exit-transform))
-      (let ((yas-after-exit-snippet-hook snippet-exit-hook))
-        (yas--safely-run-hook 'yas-after-exit-snippet-hook)))))
-
-;; Apropos markers-to-points:
-;;
-;; This was found useful for performance reasons, so that an excessive
-;; number of live markers aren't kept around in the
-;; `buffer-undo-list'.  We don't reuse the original marker object
-;; because that leaves an unreadable object in the history list and
-;; undo-tree persistence has trouble with that.
-;;
-;; This shouldn't bring horrible problems with undo/redo, but you
-;; never know.
-;;
-(defun yas--markers-to-points (snippet)
-  "Save all markers of SNIPPET as positions."
-  (yas--snippet-map-markers (lambda (m)
-                              (prog1 (marker-position m)
-                                (set-marker m nil)))
-                            snippet))
-
-(defun yas--points-to-markers (snippet)
-  "Restore SNIPPET's marker positions, saved by `yas--markers-to-points'."
-  (yas--snippet-map-markers #'copy-marker snippet))
-
-(defun yas--maybe-move-to-active-field (snippet)
-  "Try to move to SNIPPET's active (or first) field and return it if found."
-  (let ((target-field (or (yas--snippet-active-field snippet)
-                          (car (yas--snippet-fields snippet)))))
-    (when target-field
-      (yas--move-to-field snippet target-field)
-      target-field)))
-
-(defun yas--field-contains-point-p (field &optional point)
-  (let ((point (or point
-                   (point))))
-    (and (>= point (yas--field-start field))
-         (<= point (yas--field-end field)))))
-
-(defun yas--field-text-for-display (field)
-  "Return the propertized display text for field FIELD."
-  (buffer-substring (yas--field-start field) (yas--field-end field)))
-
-(defun yas--undo-in-progress ()
-  "True if some kind of undo is in progress."
-  (or undo-in-progress
-      (eq this-command 'undo)
-      (eq this-command 'redo)))
-
-(defun yas--make-control-overlay (snippet start end)
-  "Create the control overlay that surrounds the snippet and
-holds the keymap."
-  (let ((overlay (make-overlay start
-                               end
-                               nil
-                               nil
-                               t)))
-    (overlay-put overlay 'keymap yas-keymap)
-    (overlay-put overlay 'priority yas-overlay-priority)
-    (overlay-put overlay 'yas--snippet snippet)
-    overlay))
-
-(defun yas-current-field ()
-  "Return the currently active field."
-  (and yas--active-field-overlay
-       (overlay-buffer yas--active-field-overlay)
-       (overlay-get yas--active-field-overlay 'yas--field)))
-
-(defun yas--maybe-clear-field-filter (cmd)
-  "Return CMD if at start of unmodified snippet field.
-Use as a `:filter' argument for a conditional keybinding."
-  (let ((field (yas-current-field)))
-    (when (and field
-               (not (yas--field-modified-p field))
-               (eq (point) (marker-position (yas--field-start field))))
-      cmd)))
-
-(defun yas-skip-and-clear-field (&optional field)
-  "Clears unmodified FIELD if at field start, skips to next tab."
-  (interactive)
-  (yas--skip-and-clear (or field (yas-current-field)))
-  (yas-next-field 1))
-
-(defun yas-skip-and-clear-or-delete-char (&optional field)
-  "Clears unmodified field if at field start, skips to next tab.
-
-Otherwise deletes a character normally by calling `delete-char'."
-  (interactive)
-  (declare (obsolete "Bind to `yas-maybe-skip-and-clear-field' instead." "0.13"))
-  (cond ((yas--maybe-clear-field-filter t)
-         (yas--skip-and-clear (or field (yas-current-field)))
-         (yas-next-field 1))
-        (t (call-interactively 'delete-char))))
-
-(defun yas--skip-and-clear (field &optional from)
-  "Deletes the region of FIELD and sets it's modified state to t.
-If given, FROM indicates position to start at instead of FIELD's beginning."
-  ;; Just before skipping-and-clearing the field, mark its children
-  ;; fields as modified, too. If the children have mirrors-in-fields
-  ;; this prevents them from updating erroneously (we're skipping and
-  ;; deleting!).
-  ;;
-  (yas--mark-this-and-children-modified field)
-  (unless (= (yas--field-start field) (yas--field-end field))
-    (delete-region (or from (yas--field-start field)) (yas--field-end field))))
-
-(defun yas--mark-this-and-children-modified (field)
-  (setf (yas--field-modified-p field) t)
-  (let ((fom (yas--field-next field)))
-    (while (and fom
-                (yas--fom-parent-field fom))
-      (when (and (eq (yas--fom-parent-field fom) field)
-                 (yas--field-p fom))
-        (yas--mark-this-and-children-modified fom))
-      (setq fom (yas--fom-next fom)))))
-
-(defun yas--make-move-active-field-overlay (snippet field)
-  "Place the active field overlay in SNIPPET's FIELD.
-
-Move the overlay, or create it if it does not exit."
-  (if (and yas--active-field-overlay
-           (overlay-buffer yas--active-field-overlay))
-      (move-overlay yas--active-field-overlay
-                    (yas--field-start field)
-                    (yas--field-end field))
-    (setq yas--active-field-overlay
-          (make-overlay (yas--field-start field)
-                        (yas--field-end field)
-                        nil nil t))
-    (overlay-put yas--active-field-overlay 'priority yas-overlay-priority)
-    (overlay-put yas--active-field-overlay 'face 'yas-field-highlight-face)
-    (overlay-put yas--active-field-overlay 'yas--snippet snippet)
-    (overlay-put yas--active-field-overlay 'modification-hooks '(yas--on-field-overlay-modification))
-    (overlay-put yas--active-field-overlay 'insert-in-front-hooks
-                 '(yas--on-field-overlay-modification))
-    (overlay-put yas--active-field-overlay 'insert-behind-hooks
-                 '(yas--on-field-overlay-modification))))
-
-(defun yas--skip-and-clear-field-p (field beg _end length)
-  "Tell if newly modified FIELD should be cleared and skipped.
-BEG, END and LENGTH like overlay modification hooks."
-  (and (= length 0) ; A 0 pre-change length indicates insertion.
-       (= beg (yas--field-start field)) ; Insertion at field start?
-       (not (yas--field-modified-p field))))
-
-(defun yas--on-field-overlay-modification (overlay after? beg end &optional length)
-  "Clears the field and updates mirrors, conditionally.
-
-Only clears the field if it hasn't been modified and point is at
-field start.  This hook does nothing if an undo is in progress."
-  (unless (or (not after?)
-              yas--inhibit-overlay-hooks
-              (not (overlayp yas--active-field-overlay)) ; Avoid Emacs bug #21824.
-              ;; If a single change hits multiple overlays of the same
-              ;; snippet, then we delete the snippet the first time,
-              ;; and then subsequent calls get a deleted overlay.
-              ;; Don't delete the snippet again!
-              (not (overlay-buffer overlay))
-              (yas--undo-in-progress))
-    (let* ((inhibit-modification-hooks nil)
-           (yas--inhibit-overlay-hooks t)
-           (field (overlay-get overlay 'yas--field))
-           (snippet (overlay-get yas--active-field-overlay 'yas--snippet)))
-      (if (yas--snippet-live-p snippet)
-          (save-match-data
-            (yas--letenv (yas--snippet-expand-env snippet)
-              (when (yas--skip-and-clear-field-p field beg end length)
-                ;; We delete text starting from the END of insertion.
-                (yas--skip-and-clear field end))
-              (setf (yas--field-modified-p field) t)
-              (yas--advance-end-maybe field (overlay-end overlay))
-              (save-excursion
-                (yas--field-update-display field))
-              (yas--update-mirrors snippet)))
-        (lwarn '(yasnippet zombie) :warning "Killing zombie snippet!")
-        (delete-overlay overlay)))))
-
-(defun yas--auto-fill ()
-  (let* ((orig-point (point))
-         (end (progn (forward-paragraph) (point)))
-         (beg (progn (backward-paragraph) (point)))
-         (snippets (yas-active-snippets beg end))
-         (remarkers nil)
-         (reoverlays nil))
-    (dolist (snippet snippets)
-      (dolist (m (yas--collect-snippet-markers snippet))
-        (when (and (<= beg m) (<= m end))
-          (push (yas--snapshot-marker-location m beg end) remarkers)))
-      (push (yas--snapshot-overlay-location
-             (yas--snippet-control-overlay snippet) beg end)
-            reoverlays))
-    (goto-char orig-point)
-    (let ((yas--inhibit-overlay-hooks t))
-      (if (null yas--original-auto-fill-function)
-          ;; Try to get more info on #873/919.
-          (let ((yas--fill-fun-values `((t ,(default-value 'yas--original-auto-fill-function))))
-                (fill-fun-values `((t ,(default-value 'auto-fill-function))))
-                ;; Listing 2 buffers with the same value is enough
-                (print-length 3))
-            (save-current-buffer
-              (dolist (buf (let ((bufs (buffer-list)))
-                             ;; List the current buffer first.
-                             (setq bufs (cons (current-buffer)
-                                              (remq (current-buffer) bufs)))))
-                (set-buffer buf)
-                (let* ((yf-cell (assq yas--original-auto-fill-function
-                                      yas--fill-fun-values))
-                       (af-cell (assq auto-fill-function fill-fun-values)))
-                  (when (local-variable-p 'yas--original-auto-fill-function)
-                    (if yf-cell (setcdr yf-cell (cons buf (cdr yf-cell)))
-                      (push (list yas--original-auto-fill-function buf) yas--fill-fun-values)))
-                  (when (local-variable-p 'auto-fill-function)
-                    (if af-cell (setcdr af-cell (cons buf (cdr af-cell)))
-                      (push (list auto-fill-function buf) fill-fun-values))))))
-                 (lwarn '(yasnippet auto-fill bug) :error
-                        "`yas--original-auto-fill-function' unexpectedly nil in %S!  Disabling auto-fill.
-  %S
-  `auto-fill-function': %S\n%s"
-                        (current-buffer) yas--fill-fun-values fill-fun-values
-                        (if (fboundp 'backtrace--print-frame)
-                            (with-output-to-string
-                              (mapc (lambda (frame)
-                                      (apply #'backtrace--print-frame frame))
-                                    yas--watch-auto-fill-backtrace))
-                          ""))
-                 ;; Try to avoid repeated triggering of this bug.
-                 (auto-fill-mode -1)
-                 ;; Don't pop up more than once in a session (still log though).
-                 (defvar warning-suppress-types) ; `warnings' is autoloaded by `lwarn'.
-                 (add-to-list 'warning-suppress-types '(yasnippet auto-fill bug)))
-        (funcall yas--original-auto-fill-function)))
-    (save-excursion
-      (setq end (progn (forward-paragraph) (point)))
-      (setq beg (progn (backward-paragraph) (point))))
-    (save-excursion
-      (save-restriction
-        (narrow-to-region beg end)
-        (mapc #'yas--restore-marker-location remarkers)
-        (mapc #'yas--restore-overlay-location reoverlays))
-      (mapc (lambda (snippet)
-              (yas--letenv (yas--snippet-expand-env snippet)
-                (yas--update-mirrors snippet)))
-            snippets))))
-
-
-;;; Apropos protection overlays:
-;;
-;; These exist for nasty users who will try to delete parts of the
-;; snippet outside the active field. Actual protection happens in
-;; `yas--on-protection-overlay-modification'.
-;;
-;; As of github #537 this no longer inhibits the command by issuing an
-;; error: all the snippets at point, including nested snippets, are
-;; automatically commited and the current command can proceed.
-;;
-(defun yas--make-move-field-protection-overlays (snippet field)
-  "Place protection overlays surrounding SNIPPET's FIELD.
-
-Move the overlays, or create them if they do not exit."
-  (let ((start (yas--field-start field))
-        (end (yas--field-end field)))
-    ;; First check if the (1+ end) is contained in the buffer,
-    ;; otherwise we'll have to do a bit of cheating and silently
-    ;; insert a newline. the `(1+ (buffer-size))' should prevent this
-    ;; when using stacked expansion
-    ;;
-    (when (< (buffer-size) end)
-      (save-excursion
-        (let ((yas--inhibit-overlay-hooks t))
-          (goto-char (point-max))
-          (newline))))
-    ;; go on to normal overlay creation/moving
-    ;;
-    (cond ((and yas--field-protection-overlays
-                (cl-every #'overlay-buffer yas--field-protection-overlays))
-           (move-overlay (nth 0 yas--field-protection-overlays)
-                         (1- start) start)
-           (move-overlay (nth 1 yas--field-protection-overlays) end (1+ end)))
-          (t
-           (setq yas--field-protection-overlays
-                 (list (make-overlay (1- start) start nil t nil)
-                       (make-overlay end (1+ end) nil t nil)))
-           (dolist (ov yas--field-protection-overlays)
-             (overlay-put ov 'face 'yas--field-debug-face)
-             (overlay-put ov 'yas--snippet snippet)
-             ;; (overlay-put ov 'evaporate t)
-             (overlay-put ov 'modification-hooks '(yas--on-protection-overlay-modification)))))))
-
-(defun yas--on-protection-overlay-modification (_overlay after? beg end &optional length)
-  "Commit the snippet if the protection overlay is being killed."
-  (unless (or yas--inhibit-overlay-hooks
-              (not after?)
-              (= length (- end beg)) ; deletion or insertion
-              (yas--undo-in-progress))
-    (let ((snippets (yas-active-snippets)))
-      (yas--message 2 "Committing snippets. Action would destroy a protection overlay.")
-      (cl-loop for snippet in snippets
-               do (yas--commit-snippet snippet)))))
-
-(add-to-list 'debug-ignored-errors "^Exit the snippet first!$")
-
-
-;;; Snippet expansion and "stacked" expansion:
-;;
-;; Stacked expansion is when you try to expand a snippet when already
-;; inside a snippet expansion.
-;;
-;; The parent snippet does not run its fields modification hooks
-;; (`yas--on-field-overlay-modification' and
-;; `yas--on-protection-overlay-modification') while the child snippet
-;; is active. This means, among other things, that the mirrors of the
-;; parent snippet are not updated, this only happening when one exits
-;; the child snippet.
-;;
-;; Unfortunately, this also puts some ugly (and not fully-tested)
-;; bits of code in `yas-expand-snippet' and
-;; `yas--commit-snippet'. I've tried to mark them with "stacked
-;; expansion:".
-;;
-;; This was thought to be safer in an undo/redo perspective, but
-;; maybe the correct implementation is to make the globals
-;; `yas--active-field-overlay' and `yas--field-protection-overlays' be
-;; snippet-local and be active even while the child snippet is
-;; running. This would mean a lot of overlay modification hooks
-;; running, but if managed correctly (including overlay priorities)
-;; they should account for all situations...
-
-(defun yas-expand-snippet (snippet &optional start end expand-env)
-  "Expand SNIPPET at current point.
-
-Text between START and END will be deleted before inserting
-template.  EXPAND-ENV is a list of (SYM VALUE) let-style dynamic
-bindings considered when expanding the snippet.  If omitted, use
-SNIPPET's expand-env field.
-
-SNIPPET may be a snippet structure (e.g., as returned by
-`yas-lookup-snippet'), or just a snippet body (which is a string
-for normal snippets, and a list for command snippets)."
-  (cl-assert (and yas-minor-mode
-                  (memq 'yas--post-command-handler post-command-hook))
-             nil
-             "[yas] `yas-expand-snippet' needs properly setup `yas-minor-mode'")
-  (run-hooks 'yas-before-expand-snippet-hook)
-
-  (let* ((clear-field
-          (let ((field (and yas--active-field-overlay
-                            (overlay-buffer yas--active-field-overlay)
-                            (overlay-get yas--active-field-overlay 'yas--field))))
-            (and field (yas--skip-and-clear-field-p
-                        field (point) (point) 0)
-                 field)))
-         (start (cond (start)
-                      ((region-active-p)
-                       (region-beginning))
-                      (clear-field
-                       (yas--field-start clear-field))
-                      (t (point))))
-         (end (cond (end)
-                    ((region-active-p)
-                     (region-end))
-                    (clear-field
-                     (yas--field-end clear-field))
-                    (t (point))))
-         (to-delete (and (> end start)
-                         (buffer-substring-no-properties start end)))
-         (yas-selected-text
-          (cond (yas-selected-text)
-                ((and (region-active-p)
-                      (not clear-field))
-                 to-delete))))
-    (goto-char start)
-    (setq yas--indent-original-column (current-column))
-    ;; Delete the region to delete, this *does* get undo-recorded.
-    (when to-delete
-      (delete-region start end))
-
-    (let ((content (if (yas--template-p snippet)
-                       (yas--template-content snippet)
-                     snippet)))
-      (when (and (not expand-env) (yas--template-p snippet))
-        (setq expand-env (yas--template-expand-env snippet)))
-      (cond ((listp content)
-             ;; x) This is a snippet-command.
-             (yas--eval-for-effect content))
-            (t
-             ;; x) This is a snippet-snippet :-)
-             (setq yas--start-column (current-column))
-             ;; Stacked expansion: also shoosh the overlay modification hooks.
-             (let ((yas--inhibit-overlay-hooks t))
-               (setq snippet
-                     (yas--snippet-create content expand-env start (point))))
-
-             ;; Stacked-expansion: This checks for stacked expansion, save the
-             ;; `yas--previous-active-field' and advance its boundary.
-             (let ((existing-field (and yas--active-field-overlay
-                                        (overlay-buffer yas--active-field-overlay)
-                                        (overlay-get yas--active-field-overlay 'yas--field))))
-               (when existing-field
-                 (setf (yas--snippet-previous-active-field snippet) existing-field)
-                 (yas--advance-end-maybe existing-field (overlay-end yas--active-field-overlay))))
-
-             ;; Exit the snippet immediately if no fields.
-             (unless (yas--snippet-fields snippet)
-               (yas-exit-snippet snippet))
-
-             ;; Now, schedule a move to the first field.
-             (let ((first-field (car (yas--snippet-fields snippet))))
-               (when first-field
-                 (sit-for 0) ;; fix issue 125
-                 (yas--letenv (yas--snippet-expand-env snippet)
-                   (yas--move-to-field snippet first-field))
-                 (when (and (eq (yas--field-number first-field) 0)
-                            (> (length (yas--field-text-for-display
-                                        first-field))
-                               0))
-                   ;; Keep region for ${0:exit text}.
-                   (setq deactivate-mark nil))))
-             (yas--message 4 "snippet %d expanded." (yas--snippet-id snippet))
-             t)))))
-
-(defun yas--take-care-of-redo (snippet)
-  "Commits SNIPPET, which in turn pushes an undo action for reviving it.
-
-Meant to exit in the `buffer-undo-list'."
-  ;; slightly optimize: this action is only needed for snippets with
-  ;; at least one field
-  (when (yas--snippet-fields snippet)
-    (yas--commit-snippet snippet)))
-
-(defun yas--snippet-revive (beg end snippet)
-  "Revives SNIPPET and creates a control overlay from BEG to END.
-
-BEG and END are, we hope, the original snippets boundaries.
-All the markers/points exiting existing inside SNIPPET should point
-to their correct locations *at the time the snippet is revived*.
-
-After revival, push the `yas--take-care-of-redo' in the
-`buffer-undo-list'"
-  ;; Reconvert all the points to markers
-  (yas--points-to-markers snippet)
-  ;; When at least one editable field existed in the zombie snippet,
-  ;; try to revive the whole thing...
-  (when (yas--maybe-move-to-active-field snippet)
-    (setf (yas--snippet-control-overlay snippet) (yas--make-control-overlay snippet beg end))
-    (overlay-put (yas--snippet-control-overlay snippet) 'yas--snippet snippet)
-    (when (listp buffer-undo-list)
-      (push `(apply yas--take-care-of-redo ,snippet)
-            buffer-undo-list))))
-
-(defun yas--snippet-create (content expand-env begin end)
-  "Create a snippet from a template inserted at BEGIN to END.
-
-Returns the newly created snippet."
-  (save-restriction
-    (let ((snippet (yas--make-snippet expand-env)))
-      (yas--letenv expand-env
-        ;; Put a single undo action for the expanded snippet's
-        ;; content.
-        (let ((buffer-undo-list t))
-          ;; Some versions of cc-mode fail when inserting snippet
-          ;; content in a narrowed buffer.
-          (goto-char begin)
-          (insert content)
-          (setq end (+ end (length content)))
-          (narrow-to-region begin end)
-          (goto-char (point-min))
-          (yas--snippet-parse-create snippet))
-        (when (listp buffer-undo-list)
-          (push (cons (point-min) (point-max))
-                buffer-undo-list))
-
-        ;; Indent, collecting undo information normally.
-        (yas--indent snippet)
-
-        ;; Follow up with `yas--take-care-of-redo' on the newly
-        ;; inserted snippet boundaries.
-        (when (listp buffer-undo-list)
-          (push `(apply yas--take-care-of-redo ,snippet)
-                buffer-undo-list))
-
-        ;; Sort and link each field
-        (yas--snippet-sort-fields snippet)
-
-        ;; Create keymap overlay for snippet
-        (setf (yas--snippet-control-overlay snippet)
-              (yas--make-control-overlay snippet (point-min) (point-max)))
-
-        ;; Move to end
-        (goto-char (point-max))
-
-        (push snippet yas--active-snippets)
-        snippet))))
-
-
-;;; Apropos adjacencies and "fom's":
-;;
-;; Once the $-constructs bits like "$n" and "${:n" are deleted in the
-;; recently expanded snippet, we might actually have many fields,
-;; mirrors (and the snippet exit) in the very same position in the
-;; buffer. Therefore we need to single-link the
-;; fields-or-mirrors-or-exit (which I have abbreviated to "fom")
-;; according to their original positions in the buffer.
-;;
-;; Then we have operation `yas--advance-end-maybe' and
-;; `yas--advance-start-maybe', which conditionally push the starts and
-;; ends of these foms down the chain.
-;;
-;; This allows for like the printf with the magic ",":
-;;
-;;   printf ("${1:%s}\\n"${1:$(if (string-match "%" text) "," "\);")}  \
-;;   $2${1:$(if (string-match "%" text) "\);" "")}$0
-;;
-(defun yas--fom-start (fom)
-  (cond ((yas--field-p fom)
-         (yas--field-start fom))
-        ((yas--mirror-p fom)
-         (yas--mirror-start fom))
-        (t
-         (yas--exit-marker fom))))
-
-(defun yas--fom-end (fom)
-  (cond ((yas--field-p fom)
-         (yas--field-end fom))
-        ((yas--mirror-p fom)
-         (yas--mirror-end fom))
-        (t
-         (yas--exit-marker fom))))
-
-(defun yas--fom-next (fom)
-  (cond ((yas--field-p fom)
-         (yas--field-next fom))
-        ((yas--mirror-p fom)
-         (yas--mirror-next fom))
-        (t
-         (yas--exit-next fom))))
-
-(defun yas--fom-parent-field (fom)
-  (cond ((yas--field-p fom)
-         (yas--field-parent-field fom))
-        ((yas--mirror-p fom)
-         (yas--mirror-parent-field fom))
-        (t
-         nil)))
-
-(defun yas--calculate-adjacencies (snippet)
-  "Calculate adjacencies for fields or mirrors of SNIPPET.
-
-This is according to their relative positions in the buffer, and
-has to be called before the $-constructs are deleted."
-  (let* ((fom-set-next-fom
-         (lambda (fom nextfom)
-           (cond ((yas--field-p fom)
-                  (setf (yas--field-next fom) nextfom))
-                 ((yas--mirror-p fom)
-                  (setf (yas--mirror-next fom) nextfom))
-                 (t
-                  (setf (yas--exit-next fom) nextfom)))))
-        (compare-fom-begs
-         (lambda (fom1 fom2)
-           (if (= (yas--fom-start fom2) (yas--fom-start fom1))
-               (yas--mirror-p fom2)
-             (>= (yas--fom-start fom2) (yas--fom-start fom1)))))
-        (link-foms fom-set-next-fom))
-    ;; make some yas--field, yas--mirror and yas--exit soup
-    (let ((soup))
-      (when (yas--snippet-exit snippet)
-        (push (yas--snippet-exit snippet) soup))
-      (dolist (field (yas--snippet-fields snippet))
-        (push field soup)
-        (dolist (mirror (yas--field-mirrors field))
-          (push mirror soup)))
-      (setq soup
-            (sort soup compare-fom-begs))
-      (when soup
-        (cl-reduce link-foms soup)))))
-
-(defun yas--calculate-simple-fom-parentage (snippet fom)
-  "Discover if FOM is parented by some field in SNIPPET.
-
-Use the tightest containing field if more than one field contains
-the mirror.  Intended to be called *before* the dollar-regions are
-deleted."
-  (let ((min (point-min))
-        (max (point-max)))
-    (dolist (field (remq fom (yas--snippet-fields snippet)))
-      (when (and (<= (yas--field-start field) (yas--fom-start fom))
-                 (<= (yas--fom-end fom) (yas--field-end field))
-               (< min (yas--field-start field))
-               (< (yas--field-end field) max))
-          (setq min (yas--field-start field)
-                max (yas--field-end field))
-          (cond ((yas--field-p fom)
-                 (setf (yas--field-parent-field fom) field))
-                ((yas--mirror-p fom)
-                 (setf (yas--mirror-parent-field fom) field))
-                (t ; it's an exit, so noop
-                 nil ))))))
-
-(defun yas--advance-end-maybe (fom newend)
-  "Maybe advance FOM's end to NEWEND if it needs it.
-
-If it does, also:
-
-* call `yas--advance-start-maybe' on FOM's next fom.
-
-* in case FOM is field call `yas--advance-end-maybe' on its parent
-  field
-
-Also, if FOM is an exit-marker, always call
-`yas--advance-start-maybe' on its next fom.  This is because
-exit-marker have identical start and end markers."
-  (cond ((and fom (< (yas--fom-end fom) newend))
-         (set-marker (yas--fom-end fom) newend)
-         (yas--advance-start-maybe (yas--fom-next fom) newend)
-         (yas--advance-end-of-parents-maybe (yas--fom-parent-field fom) newend))
-        ((yas--exit-p fom)
-         (yas--advance-start-maybe (yas--fom-next fom) newend))))
-
-(defun yas--advance-start-maybe (fom newstart)
-  "Maybe advance FOM's start to NEWSTART if it needs it.
-
-If it does, also call `yas--advance-end-maybe' on FOM."
-  (when (and fom (< (yas--fom-start fom) newstart))
-    (set-marker (yas--fom-start fom) newstart)
-    (yas--advance-end-maybe fom newstart)))
-
-(defun yas--advance-end-of-parents-maybe (field newend)
-  "Like `yas--advance-end-maybe' but for parent fields.
-
-Only works for fields and doesn't care about the start of the
-next FOM.  Works its way up recursively for parents of parents."
-  (when (and field
-             (< (yas--field-end field) newend))
-    (set-marker (yas--field-end field) newend)
-    (yas--advance-end-of-parents-maybe (yas--field-parent-field field) newend)))
-
-(defvar yas--dollar-regions nil
-  "When expanding the snippet the \"parse-create\" functions add
-cons cells to this var.")
-
-(defvar yas--indent-markers nil
-  "List of markers for manual indentation.")
-
-(defun yas--snippet-parse-create (snippet)
-  "Parse a recently inserted snippet template, creating all
-necessary fields, mirrors and exit points.
-
-Meant to be called in a narrowed buffer, does various passes"
-  (let ((saved-quotes nil)
-        (parse-start (point)))
-    ;; Avoid major-mode's syntax propertizing function, since we
-    ;; change the syntax-table while calling `scan-sexps'.
-    (let ((syntax-propertize-function nil))
-      (setq yas--dollar-regions nil)  ; Reset the yas--dollar-regions.
-      (yas--protect-escapes nil '(?`))  ; Protect just the backquotes.
-      (goto-char parse-start)
-      (setq saved-quotes (yas--save-backquotes)) ; `expressions`.
-      (yas--protect-escapes)            ; Protect escaped characters.
-      (goto-char parse-start)
-      (yas--indent-parse-create)        ; Parse indent markers: `$>'.
-      (goto-char parse-start)
-      (yas--field-parse-create snippet) ; Parse fields with {}.
-      (goto-char parse-start)
-      (yas--simple-fom-create snippet) ; Parse simple mirrors & fields.
-      (goto-char parse-start)
-      (yas--transform-mirror-parse-create snippet) ; Parse mirror transforms.
-      ;; Invalidate any syntax-propertizing done while
-      ;; `syntax-propertize-function' was nil.
-      (syntax-ppss-flush-cache parse-start))
-    ;; Set "next" links of fields & mirrors.
-    (yas--calculate-adjacencies snippet)
-    (yas--save-restriction-and-widen    ; Delete $-constructs.
-      (yas--delete-regions yas--dollar-regions))
-    ;; Make sure to do this insertion *after* deleting the dollar
-    ;; regions, otherwise we invalidate the calculated positions of
-    ;; all the fields following $0.
-    (let ((exit (yas--snippet-exit snippet)))
-      (goto-char (if exit (yas--exit-marker exit) (point-max))))
-    (when (eq yas-wrap-around-region 'cua)
-      (setq yas-wrap-around-region ?0))
-    (cond ((and yas-wrap-around-region yas-selected-text)
-           (insert yas-selected-text))
-          ((and (characterp yas-wrap-around-region)
-                (get-register yas-wrap-around-region))
-           (insert (prog1 (get-register yas-wrap-around-region)
-                     (set-register yas-wrap-around-region nil)))))
-    (yas--restore-backquotes saved-quotes)  ; Restore `expression` values.
-    (goto-char parse-start)
-    (yas--restore-escapes)        ; Restore escapes.
-    (yas--update-mirrors snippet) ; Update mirrors for the first time.
-    (goto-char parse-start)))
-
-;; HACK: Some implementations of `indent-line-function' (called via
-;; `indent-according-to-mode') delete text before they insert (like
-;; cc-mode), some make complicated regexp replacements (looking at
-;; you, org-mode).  To find place where the marker "should" go after
-;; indentation, we create a regexp based on what the line looks like
-;; before, putting a capture group where the marker is.  The regexp
-;; matches any whitespace with [[:space:]]* to allow for the
-;; indentation changing whitespace.  Additionally, we try to preserve
-;; the amount of whitespace *following* the marker, because
-;; indentation generally affects whitespace at the beginning, not the
-;; end.
-;;
-;; Two other cases where we apply a similar strategy:
-;;
-;; 1. Handling `auto-fill-mode', in this case we need to use the
-;; current paragraph instead of line.
-;;
-;; 2. Moving snippets from an `org-src' temp buffer into the main org
-;; buffer, in this case we need to count the line offsets (because org
-;; may add indentation on each line making character positions
-;; unreliable).
-;;
-;; This is all best-effort heuristic stuff, but it should cover 99% of
-;; use-cases.
-
-(defun yas--snapshot-marker-location (marker &optional beg end)
-  "Returns info for restoring MARKER's location after indent.
-The returned value is a list of the form (MARKER REGEXP WS-COUNT)."
-  (unless beg (setq beg (line-beginning-position)))
-  (unless end (setq end (line-end-position)))
-  (let ((before (split-string (buffer-substring-no-properties beg marker)
-                              "[[:space:]\n]+" t))
-        (after (split-string (buffer-substring-no-properties marker end)
-                             "[[:space:]\n]+" t)))
-    (list marker
-          (concat "[[:space:]\n]*"
-                  (mapconcat (lambda (s)
-                               (if (eq s marker) "\\(\\)"
-                                 (regexp-quote s)))
-                             (nconc before (list marker) after)
-                             "[[:space:]\n]*"))
-          (progn (goto-char marker)
-                 (skip-chars-forward "[:space:]\n" end)
-                 (- (point) marker)))))
-
-(defun yas--snapshot-overlay-location (overlay beg end)
-  "Like `yas--snapshot-marker-location' for overlays.
-The returned format is (OVERLAY (RE WS) (RE WS)).  Either of
-the (RE WS) lists may be nil if the start or end, respectively,
-of the overlay is outside the range BEG .. END."
-  (let ((obeg (overlay-start overlay))
-        (oend (overlay-end overlay)))
-    (list overlay
-          (when (and (<= beg obeg) (< obeg end))
-            (cdr (yas--snapshot-marker-location obeg beg end)))
-          (when (and (<= beg oend) (< oend end))
-            (cdr (yas--snapshot-marker-location oend beg end))))))
-
-(defun yas--snapshot-overlay-line-location (overlay)
-  "Return info for restoring OVERLAY's line based location.
-The returned format is (OVERLAY (LINE RE WS) (LINE RE WS))."
-  (let ((loc-beg (progn (goto-char (overlay-start overlay))
-                        (yas--snapshot-marker-location (point))))
-        (loc-end (progn (goto-char (overlay-end overlay))
-                        (yas--snapshot-marker-location (point)))))
-    (setcar loc-beg (count-lines (point-min) (progn (goto-char (car loc-beg))
-                                                    (line-beginning-position))))
-    (setcar loc-end (count-lines (point-min) (progn (goto-char (car loc-end))
-                                                    (line-beginning-position))))
-    (list overlay loc-beg loc-end)))
-
-(defun yas--goto-saved-location (regexp ws-count)
-  "Move point to location saved by `yas--snapshot-marker-location'.
-Buffer must be narrowed to BEG..END used to create the snapshot info."
-  (goto-char (point-min))
-  (if (not (looking-at regexp))
-      (lwarn '(yasnippet re-marker) :warning
-             "Couldn't find: %S" regexp)
-    (goto-char (match-beginning 1))
-    (skip-chars-forward "[:space:]\n")
-    (skip-chars-backward "[:space:]\n" (- (point) ws-count))))
-
-(defun yas--restore-marker-location (re-marker)
-  "Restores marker based on info from `yas--snapshot-marker-location'.
-Buffer must be narrowed to BEG..END used to create the snapshot info."
-  (apply #'yas--goto-saved-location (cdr re-marker))
-  (set-marker (car re-marker) (point)))
-
-(defun yas--restore-overlay-location (ov-locations)
-  "Restores marker based on info from `yas--snapshot-marker-location'.
-Buffer must be narrowed to BEG..END used to create the snapshot info."
-  (cl-destructuring-bind (overlay loc-beg loc-end) ov-locations
-    (move-overlay overlay
-                  (if (not loc-beg) (overlay-start overlay)
-                    (apply #'yas--goto-saved-location loc-beg)
-                    (point))
-                  (if (not loc-end) (overlay-end overlay)
-                    (apply #'yas--goto-saved-location loc-end)
-                    (point)))))
-
-
-(defun yas--restore-overlay-line-location (ov-locations)
-  "Restores overlay based on info from `yas--snapshot-overlay-line-location'."
-  (save-restriction
-    (move-overlay (car ov-locations)
-                  (save-excursion
-                    (forward-line (car (nth 1 ov-locations)))
-                    (narrow-to-region (line-beginning-position) (line-end-position))
-                    (apply #'yas--goto-saved-location (cdr (nth 1 ov-locations)))
-                    (point))
-                  (save-excursion
-                    (forward-line (car (nth 2 ov-locations)))
-                    (narrow-to-region (line-beginning-position) (line-end-position))
-                    (apply #'yas--goto-saved-location (cdr (nth 2 ov-locations)))
-                    (point)))))
-
-(defun yas--indent-region (from to snippet)
-  "Indent the lines between FROM and TO with `indent-according-to-mode'.
-The SNIPPET's markers are preserved."
-  (save-excursion
-    (yas--save-restriction-and-widen
-      (let* ((snippet-markers (yas--collect-snippet-markers snippet))
-             (to (set-marker (make-marker) to)))
-        (goto-char from)
-        (cl-loop for bol = (line-beginning-position)
-                 for eol = (line-end-position)
-                 if (or yas-also-indent-empty-lines
-                        (/= bol eol))
-                 do
-                 ;; Indent each non-empty line.
-                 (let ((remarkers nil))
-                   (dolist (m snippet-markers)
-                     (when (and (<= bol m) (<= m eol))
-                       (push (yas--snapshot-marker-location m bol eol)
-                             remarkers)))
-                   (unwind-protect
-                       (progn (back-to-indentation)
-                              (indent-according-to-mode))
-                     (save-restriction
-                       (narrow-to-region bol (line-end-position))
-                       (mapc #'yas--restore-marker-location remarkers))))
-                 while (and (zerop (forward-line 1))
-                            (< (point) to)))))))
-
-(defvar yas--indent-original-column nil)
-(defun yas--indent (snippet)
-  ;; Indent lines that had indent markers (`$>') on them.
-  (save-excursion
-    (dolist (marker yas--indent-markers)
-      (unless (eq yas-indent-line 'auto)
-        (goto-char marker)
-        (yas--indent-region (line-beginning-position)
-                            (line-end-position)
-                            snippet))
-      ;; Finished with this marker.
-      (set-marker marker nil))
-    (setq yas--indent-markers nil))
-  ;; Now do stuff for `fixed' and `auto'.
-  (save-excursion
-    ;; We need to be at end of line, so that `forward-line' will only
-    ;; report 0 if it actually moves over a newline.
-    (end-of-line)
-    (cond ((eq yas-indent-line 'fixed)
-           (when (= (forward-line 1) 0)
-             (let ((indent-line-function
-                    (lambda ()
-                      ;; We need to be at beginning of line in order to
-                      ;; indent existing whitespace correctly.
-                      (beginning-of-line)
-                      (indent-to-column yas--indent-original-column))))
-               (yas--indent-region (line-beginning-position)
-                                   (point-max)
-                                   snippet))))
-          ((eq yas-indent-line 'auto)
-           (when (or yas-also-auto-indent-first-line
-                     (= (forward-line 1) 0))
-             (yas--indent-region (line-beginning-position)
-                                 (point-max)
-                                 snippet))))))
-
-(defun yas--collect-snippet-markers (snippet)
-  "Make a list of all the markers used by SNIPPET."
-  (let (markers)
-    (yas--snippet-map-markers (lambda (m) (push m markers) m) snippet)
-    markers))
-
-(defun yas--escape-string (escaped)
-  (concat "YASESCAPE" (format "%d" escaped) "PROTECTGUARD"))
-
-(defun yas--protect-escapes (&optional text escaped)
-  "Protect all escaped characters with their numeric ASCII value.
-
-With optional string TEXT do it in string instead of buffer."
-  (let ((changed-text text)
-        (text-provided-p text))
-    (mapc #'(lambda (escaped)
-              (setq changed-text
-                    (yas--replace-all (concat "\\" (char-to-string escaped))
-                                     (yas--escape-string escaped)
-                                     (when text-provided-p changed-text))))
-          (or escaped yas--escaped-characters))
-    changed-text))
-
-(defun yas--restore-escapes (&optional text escaped)
-  "Restore all escaped characters from their numeric ASCII value.
-
-With optional string TEXT do it in string instead of the buffer."
-  (let ((changed-text text)
-        (text-provided-p text))
-    (mapc #'(lambda (escaped)
-              (setq changed-text
-                    (yas--replace-all (yas--escape-string escaped)
-                                     (char-to-string escaped)
-                                     (when text-provided-p changed-text))))
-          (or escaped yas--escaped-characters))
-    changed-text))
-
-(defun yas--save-backquotes ()
-  "Save all \"\\=`(lisp-expression)\\=`\"-style expressions.
-Return a list of (MARKER . STRING) entires for each backquoted
-Lisp expression."
-  (let* ((saved-quotes nil)
-         (yas--snippet-buffer (current-buffer))
-         (yas--change-detected nil)
-         (detect-change (lambda (_beg _end)
-                          (when (eq (current-buffer) yas--snippet-buffer)
-                            (setq yas--change-detected t)))))
-    (while (re-search-forward yas--backquote-lisp-expression-regexp nil t)
-      (let ((current-string (match-string-no-properties 1)) transformed)
-        (yas--save-restriction-and-widen
-          (delete-region (match-beginning 0) (match-end 0)))
-        (let ((before-change-functions
-               (cons detect-change before-change-functions)))
-          (setq transformed (yas--eval-for-string (yas--read-lisp
-                                                   (yas--restore-escapes
-                                                    current-string '(?`))))))
-        (goto-char (match-beginning 0))
-        (when transformed
-          (let ((marker (make-marker))
-                (before-change-functions (cdr before-change-functions)))
-            (yas--save-restriction-and-widen
-              (insert "Y") ;; quite horrendous, I love it :)
-              (set-marker marker (point))
-              (insert "Y"))
-            (push (cons marker transformed) saved-quotes)))))
-    (when yas--change-detected
-      (lwarn '(yasnippet backquote-change) :warning
-             "`%s' modified buffer in a backquote expression.
-  To hide this warning, add (yasnippet backquote-change) to `warning-suppress-types'."
-             (if yas--current-template
-                 (yas--template-name yas--current-template)
-               "Snippet")))
-    saved-quotes))
-
-(defun yas--restore-backquotes (saved-quotes)
-  "Replace markers in SAVED-QUOTES with their values.
-SAVED-QUOTES is the in format returned by `yas--save-backquotes'."
-  (cl-loop for (marker . string) in saved-quotes do
-           (save-excursion
-             (goto-char marker)
-             (yas--save-restriction-and-widen
-               (delete-char -1)
-               (insert string)
-               (delete-char 1))
-             (set-marker marker nil))))
-
-(defun yas--scan-sexps (from count)
-  (ignore-errors
-    (save-match-data ; `scan-sexps' may modify match data.
-      (with-syntax-table (standard-syntax-table)
-        (let ((parse-sexp-lookup-properties nil))
-          (scan-sexps from count))))))
-
-(defun yas--make-marker (pos)
-  "Create a marker at POS with nil `marker-insertion-type'."
-  (let ((marker (set-marker (make-marker) pos)))
-    (set-marker-insertion-type marker nil)
-    marker))
-
-(defun yas--indent-parse-create ()
-  "Parse the \"$>\" indentation markers just inserted."
-  (setq yas--indent-markers ())
-  (while (search-forward "$>" nil t)
-    (delete-region (match-beginning 0) (match-end 0))
-    ;; Mark the beginning of the line.
-    (push (yas--make-marker (line-beginning-position))
-          yas--indent-markers))
-  (setq yas--indent-markers (nreverse yas--indent-markers)))
-
-(defun yas--field-parse-create (snippet &optional parent-field)
-  "Parse most field expressions in SNIPPET, except for the simple one \"$n\".
-
-The following count as a field:
-
-* \"${n: text}\", for a numbered field with default text, as long as N is not 0;
-
-* \"${n: text$(expression)}, the same with a Lisp expression;
-  this is caught with the curiously named `yas--multi-dollar-lisp-expression-regexp'
-
-* the same as above but unnumbered, (no N:) and number is calculated automatically.
-
-When multiple expressions are found, only the last one counts."
-  ;;
-  (save-excursion
-    (while (re-search-forward yas--field-regexp nil t)
-      (let* ((real-match-end-0 (yas--scan-sexps (1+ (match-beginning 0)) 1))
-             (number (and (match-string-no-properties 1)
-                          (string-to-number (match-string-no-properties 1))))
-             (brand-new-field (and real-match-end-0
-                                   ;; break if on "$(" immediately
-                                   ;; after the ":", this will be
-                                   ;; caught as a mirror with
-                                   ;; transform later.
-                                   (not (string-match-p "\\`\\$[ \t\n]*("
-                                                        (match-string-no-properties 2)))
-                                   ;; allow ${0: some exit text}
-                                   ;; (not (and number (zerop number)))
-                                   (yas--make-field number
-                                                   (yas--make-marker (match-beginning 2))
-                                                   (yas--make-marker (1- real-match-end-0))
-                                                   parent-field))))
-        (when brand-new-field
-          (goto-char real-match-end-0)
-          (push (cons (1- real-match-end-0) real-match-end-0)
-                yas--dollar-regions)
-          (push (cons (match-beginning 0) (match-beginning 2))
-                yas--dollar-regions)
-          (push brand-new-field (yas--snippet-fields snippet))
-          (save-excursion
-            (save-restriction
-              (narrow-to-region (yas--field-start brand-new-field) (yas--field-end brand-new-field))
-              (goto-char (point-min))
-              (yas--field-parse-create snippet brand-new-field)))))))
-  ;; if we entered from a parent field, now search for the
-  ;; `yas--multi-dollar-lisp-expression-regexp'. This is used for
-  ;; primary field transformations
-  ;;
-  (when parent-field
-    (save-excursion
-      (while (re-search-forward yas--multi-dollar-lisp-expression-regexp nil t)
-        (let* ((real-match-end-1 (yas--scan-sexps (match-beginning 1) 1)))
-          ;; commit the primary field transformation if:
-          ;;
-          ;; 1. we don't find it in yas--dollar-regions (a subnested
-          ;; field) might have already caught it.
-          ;;
-          ;; 2. we really make sure we have either two '$' or some
-          ;; text and a '$' after the colon ':'. This is a FIXME: work
-          ;; my regular expressions and end these ugly hacks.
-          ;;
-          (when (and real-match-end-1
-                     (not (member (cons (match-beginning 0)
-                                        real-match-end-1)
-                                  yas--dollar-regions))
-                     (not (eq ?:
-                              (char-before (1- (match-beginning 1))))))
-            (let ((lisp-expression-string (buffer-substring-no-properties (match-beginning 1)
-                                                                          real-match-end-1)))
-              (setf (yas--field-transform parent-field)
-                    (yas--read-lisp (yas--restore-escapes lisp-expression-string))))
-            (push (cons (match-beginning 0) real-match-end-1)
-                  yas--dollar-regions)))))))
-
-(defun yas--transform-mirror-parse-create (snippet)
-  "Parse the \"${n:$(lisp-expression)}\" mirror transformations in SNIPPET."
-  (while (re-search-forward yas--transform-mirror-regexp nil t)
-    (let* ((real-match-end-0 (yas--scan-sexps (1+ (match-beginning 0)) 1))
-           (number (string-to-number (match-string-no-properties 1)))
-           (field (and number
-                       (not (zerop number))
-                       (yas--snippet-find-field snippet number)))
-           (brand-new-mirror
-            (and real-match-end-0
-                 field
-                 (yas--make-mirror (yas--make-marker (match-beginning 0))
-                                  (yas--make-marker (match-beginning 0))
-                                  (yas--read-lisp
-                                   (yas--restore-escapes
-                                    (buffer-substring-no-properties (match-beginning 2)
-                                                                    (1- real-match-end-0))))))))
-      (when brand-new-mirror
-        (push brand-new-mirror
-              (yas--field-mirrors field))
-        (yas--calculate-simple-fom-parentage snippet brand-new-mirror)
-        (push (cons (match-beginning 0) real-match-end-0) yas--dollar-regions)))))
-
-(defun yas--simple-fom-create (snippet)
-  "Parse the simple \"$n\" fields/mirrors/exitmarkers in SNIPPET."
-  (while (re-search-forward yas--simple-mirror-regexp nil t)
-    (let ((number (string-to-number (match-string-no-properties 1))))
-      (cond ((zerop number)
-             (setf (yas--snippet-exit snippet)
-                   (yas--make-exit (yas--make-marker (match-end 0))))
-             (push (cons (match-beginning 0) (yas--exit-marker (yas--snippet-exit snippet)))
-                   yas--dollar-regions))
-            (t
-             (let ((field (yas--snippet-find-field snippet number))
-                   (fom))
-               (if field
-                   (push
-                    (setq fom (yas--make-mirror
-                               (yas--make-marker (match-beginning 0))
-                               (yas--make-marker (match-beginning 0))
-                               nil))
-                    (yas--field-mirrors field))
-                 (push
-                  (setq fom (yas--make-field number
-                                             (yas--make-marker (match-beginning 0))
-                                             (yas--make-marker (match-beginning 0))
-                                             nil))
-                  (yas--snippet-fields snippet)))
-               (yas--calculate-simple-fom-parentage snippet fom))
-             (push (cons (match-beginning 0) (match-end 0))
-                   yas--dollar-regions))))))
-
-(defun yas--delete-regions (regions)
-  "Sort disjuct REGIONS by start point, then delete from the back."
-  (mapc #'(lambda (reg)
-            (delete-region (car reg) (cdr reg)))
-        (sort regions
-              #'(lambda (r1 r2)
-                  (>= (car r1) (car r2))))))
-
-(defun yas--calculate-mirror-depth (mirror &optional traversed)
-  (let* ((parent (yas--mirror-parent-field mirror))
-         (parents-mirrors (and parent
-                               (yas--field-mirrors parent))))
-    (or (yas--mirror-depth mirror)
-        (setf (yas--mirror-depth mirror)
-              (cond ((memq mirror traversed) 0)
-                    ((and parent parents-mirrors)
-                     (1+ (cl-reduce
-                          #'max parents-mirrors
-                          :key (lambda (m)
-                                 (yas--calculate-mirror-depth
-                                  m (cons mirror traversed))))))
-                    (parent 1)
-                    (t 0))))))
-
-(defun yas--update-mirrors (snippet)
-  "Update all the mirrors of SNIPPET."
-  (yas--save-restriction-and-widen
-    (save-excursion
-      (cl-loop
-       for (field . mirror)
-       in (cl-sort
-           ;; Make a list of (FIELD . MIRROR).
-           (cl-mapcan (lambda (field)
-                        (mapcar (lambda (mirror)
-                                  (cons field mirror))
-                                (yas--field-mirrors field)))
-                      (yas--snippet-fields snippet))
-           ;; Then sort this list so that entries with mirrors with
-           ;; parent fields appear before.  This was important for
-           ;; fixing #290, and also handles the case where a mirror in
-           ;; a field causes another mirror to need reupdating.
-           #'> :key (lambda (fm) (yas--calculate-mirror-depth (cdr fm))))
-       ;; Before updating a mirror with a parent-field, maybe advance
-       ;; its start (#290).
-       do (let ((parent-field (yas--mirror-parent-field mirror)))
-            (when parent-field
-              (yas--advance-start-maybe mirror (yas--fom-start parent-field))))
-       ;; Update this mirror.
-       do (yas--mirror-update-display mirror field)
-       ;; Delay indenting until we're done all mirrors.  We must do
-       ;; this to avoid losing whitespace between fields that are
-       ;; still empty (i.e., they will be non-empty after updating).
-       when (eq yas-indent-line 'auto)
-       collect (cons (yas--mirror-start mirror) (yas--mirror-end mirror))
-       into indent-regions
-       ;; `yas--place-overlays' is needed since the active field and
-       ;; protected overlays might have been changed because of insertions
-       ;; in `yas--mirror-update-display'.
-       do (let ((active-field (yas--snippet-active-field snippet)))
-            (when active-field (yas--place-overlays snippet active-field)))
-       finally do
-       (let ((yas--inhibit-overlay-hooks t))
-         (cl-loop for (beg . end) in (cl-sort indent-regions #'< :key #'car)
-                  do (yas--indent-region beg end snippet)))))))
-
-(defun yas--mirror-update-display (mirror field)
-  "Update MIRROR according to FIELD (and mirror transform)."
-
-  (let* ((mirror-parent-field (yas--mirror-parent-field mirror))
-         (reflection (and (not (and mirror-parent-field
-                                    (yas--field-modified-p mirror-parent-field)))
-                          (or (yas--apply-transform mirror field 'empty-on-nil)
-                              (yas--field-text-for-display field)))))
-    (when (and reflection
-               (not (string= reflection (buffer-substring-no-properties (yas--mirror-start mirror)
-                                                                        (yas--mirror-end mirror)))))
-      (goto-char (yas--mirror-start mirror))
-      (let ((yas--inhibit-overlay-hooks t))
-        (insert reflection))
-      (if (> (yas--mirror-end mirror) (point))
-          (delete-region (point) (yas--mirror-end mirror))
-        (set-marker (yas--mirror-end mirror) (point))
-        (yas--advance-start-maybe (yas--mirror-next mirror) (point))
-        ;; super-special advance
-        (yas--advance-end-of-parents-maybe mirror-parent-field (point))))))
-
-(defun yas--field-update-display (field)
-  "Much like `yas--mirror-update-display', but for fields."
-  (when (yas--field-transform field)
-    (let ((transformed (and (not (eq (yas--field-number field) 0))
-                            (yas--apply-transform field field))))
-      (when (and transformed
-                 (not (string= transformed (buffer-substring-no-properties (yas--field-start field)
-                                                                           (yas--field-end field)))))
-        (setf (yas--field-modified-p field) t)
-        (goto-char (yas--field-start field))
-        (let ((yas--inhibit-overlay-hooks t))
-          (insert transformed)
-          (if (> (yas--field-end field) (point))
-              (delete-region (point) (yas--field-end field))
-            (set-marker (yas--field-end field) (point))
-            (yas--advance-start-maybe (yas--field-next field) (point)))
-          t)))))
-
-
-;;; Post-command hook:
-;;
-(defun yas--post-command-handler ()
-  "Handles various yasnippet conditions after each command."
-  (when (and yas--watch-auto-fill-backtrace
-             (fboundp 'backtrace--print-frame)
-             (null yas--original-auto-fill-function)
-             (eq auto-fill-function 'yas--auto-fill))
-    (lwarn '(yasnippet auto-fill bug) :error
-           "`yas--original-auto-fill-function' unexpectedly nil! Please report this backtrace\n%S"
-           (with-output-to-string
-             (mapc #'backtrace--print-frame
-                     yas--watch-auto-fill-backtrace)))
-    ;; Don't pop up more than once in a session (still log though).
-    (defvar warning-suppress-types) ; `warnings' is autoloaded by `lwarn'.
-    (add-to-list 'warning-suppress-types '(yasnippet auto-fill bug)))
-  (condition-case err
-      (progn (yas--finish-moving-snippets)
-             (cond ((eq 'undo this-command)
-                    ;;
-                    ;; After undo revival the correct field is sometimes not
-                    ;; restored correctly, this condition handles that
-                    ;;
-                    (let* ((snippet (car (yas-active-snippets)))
-                           (target-field
-                            (and snippet
-                                 (cl-find-if-not
-                                  (lambda (field)
-                                    (yas--field-probably-deleted-p snippet field))
-                                  (remq nil
-                                        (cons (yas--snippet-active-field snippet)
-                                              (yas--snippet-fields snippet)))))))
-                      (when target-field
-                        (yas--move-to-field snippet target-field))))
-                   ((not (yas--undo-in-progress))
-                    ;; When not in an undo, check if we must commit the snippet
-                    ;; (user exited it).
-                    (yas--check-commit-snippet))))
-    ((debug error) (signal (car err) (cdr err)))))
-
-;;; Fancy docs:
-;;
-;; The docstrings for some functions are generated dynamically
-;; depending on the context.
-;;
-(put 'yas-expand  'function-documentation
-     '(yas--expand-from-trigger-key-doc t))
-(defun yas--expand-from-trigger-key-doc (context)
-  "A doc synthesizer for `yas--expand-from-trigger-key-doc'."
-  (let* ((yas-fallback-behavior (and context yas-fallback-behavior))
-         (fallback-description
-          (cond ((eq yas-fallback-behavior 'call-other-command)
-                 (let* ((fallback (yas--keybinding-beyond-yasnippet)))
-                   (or (and fallback
-                            (format "call command `%s'."
-                                    (pp-to-string fallback)))
-                       "do nothing (`yas-expand' doesn't override\nanything).")))
-                ((eq yas-fallback-behavior 'return-nil)
-                 "do nothing.")
-                (t "defer to `yas-fallback-behavior' (which see)."))))
-    (concat "Expand a snippet before point. If no snippet
-expansion is possible, "
-            fallback-description
-            "\n\nOptional argument FIELD is for non-interactive use and is an
-object satisfying `yas--field-p' to restrict the expansion to.")))
-
-(put 'yas-expand-from-keymap 'function-documentation
-     '(yas--expand-from-keymap-doc t))
-(defun yas--expand-from-keymap-doc (context)
-  "A doc synthesizer for `yas--expand-from-keymap-doc'."
-  (add-hook 'temp-buffer-show-hook #'yas--snippet-description-finish-runonce)
-  (concat "Expand/run snippets from keymaps, possibly falling back to original binding.\n"
-          (when (and context (eq this-command 'describe-key))
-            (let* ((vec (this-single-command-keys))
-                   (templates (cl-mapcan (lambda (table)
-                                           (yas--fetch table vec))
-                                         (yas--get-snippet-tables)))
-                   (yas--direct-keymaps nil)
-                   (fallback (key-binding vec)))
-              (concat "In this case, "
-                      (when templates
-                        (concat "these snippets are bound to this key:\n"
-                                (yas--template-pretty-list templates)
-                                "\n\nIf none of these expands, "))
-                      (or (and fallback
-                               (format "fallback `%s' will be called." (pp-to-string fallback)))
-                          "no fallback keybinding is called."))))))
-
-(defun yas--template-pretty-list (templates)
-  (let ((acc)
-        (yas-buffer-local-condition 'always))
-    (dolist (plate templates)
-      (setq acc (concat acc "\n*) "
-                        (propertize (concat "\\\\snippet `" (car plate) "'")
-                                    'yasnippet (cdr plate)))))
-    acc))
-
-(define-button-type 'help-snippet-def
-  :supertype 'help-xref
-  'help-function (lambda (template) (yas--visit-snippet-file-1 template))
-  'help-echo (purecopy "mouse-2, RET: find snippets's definition"))
-
-(defun yas--snippet-description-finish-runonce ()
-  "Final adjustments for the help buffer when snippets are concerned."
-  (yas--create-snippet-xrefs)
-  (remove-hook 'temp-buffer-show-hook
-               #'yas--snippet-description-finish-runonce))
-
-(defun yas--create-snippet-xrefs ()
-  (save-excursion
-    (goto-char (point-min))
-    (while (search-forward-regexp "\\\\\\\\snippet[ \s\t]+`\\([^']+\\)'" nil t)
-      (let ((template (get-text-property (match-beginning 1)
-                                         'yasnippet)))
-        (when template
-          (help-xref-button 1 'help-snippet-def template)
-          (delete-region (match-end 1) (match-end 0))
-          (delete-region (match-beginning 0) (match-beginning 1)))))))
-
-;;; Utils
-
-(defvar yas-verbosity 3
-  "Log level for `yas--message' 4 means trace most anything, 0 means nothing.")
-
-(defun yas--message (level message &rest args)
-  "When LEVEL is at or below `yas-verbosity', log MESSAGE and ARGS."
-  (when (>= yas-verbosity level)
-    (message "%s" (apply #'yas--format message args))))
-
-(defun yas--warning (format-control &rest format-args)
-  (let ((msg (apply #'format format-control format-args)))
-    (display-warning 'yasnippet msg :warning)
-    (yas--message 1 msg)))
-
-(defun yas--format (format-control &rest format-args)
-  (apply #'format (concat "[yas] " format-control) format-args))
-
-
-;;; Unloading
-
-(defvar unload-function-defs-list) ; loadhist.el
-
-(defun yasnippet-unload-function ()
-  "Disable minor modes when calling `unload-feature'."
-  ;; Disable `yas-minor-mode' everywhere it's enabled.
-  (yas-global-mode -1)
-  (save-current-buffer
-    (dolist (buffer (buffer-list))
-      (set-buffer buffer)
-      (when yas-minor-mode
-        (yas-minor-mode -1))))
-  ;; Remove symbol properties of all our functions, this avoids
-  ;; Bug#25088 in Emacs 25.1, where the compiler macro on
-  ;; `cl-defstruct' created functions hang around in the symbol plist
-  ;; and cause errors when loading again (we don't *need* to clean
-  ;; *all* symbol plists, but it's easier than being precise).
-  (dolist (def unload-function-defs-list)
-    (when (eq (car-safe def) 'defun)
-      (setplist (cdr def) nil)))
-  ;; Return nil so that `unload-feature' will take of undefining
-  ;; functions, and changing any buffers using `snippet-mode'.
-  nil)
-
-
-;;; Backward compatibility to yasnippet <= 0.7
-
-(defun yas-initialize ()
-  "For backward compatibility, enable `yas-minor-mode' globally."
-  (declare (obsolete "Use (yas-global-mode 1) instead." "0.8"))
-  (yas-global-mode 1))
-
-(defvar yas--backported-syms '(;; `defcustom's
-                             ;;
-                             yas-snippet-dirs
-                             yas-prompt-functions
-                             yas-indent-line
-                             yas-also-auto-indent-first-line
-                             yas-snippet-revival
-                             yas-triggers-in-field
-                             yas-fallback-behavior
-                             yas-choose-keys-first
-                             yas-choose-tables-first
-                             yas-use-menu
-                             yas-trigger-symbol
-                             yas-wrap-around-region
-                             yas-good-grace
-                             yas-visit-from-menu
-                             yas-expand-only-for-last-commands
-                             yas-field-highlight-face
-
-                             ;; these vars can be customized as well
-                             ;;
-                             yas-keymap
-                             yas-verbosity
-                             yas-extra-modes
-                             yas-key-syntaxes
-                             yas-after-exit-snippet-hook
-                             yas-before-expand-snippet-hook
-                             yas-buffer-local-condition
-                             yas-dont-activate
-
-                             ;; prompting functions
-                             ;;
-                             yas-x-prompt
-                             yas-ido-prompt
-                             yas-no-prompt
-                             yas-completing-prompt
-                             yas-dropdown-prompt
-
-                             ;; interactive functions
-                             ;;
-                             yas-expand
-                             yas-minor-mode
-                             yas-global-mode
-                             yas-direct-keymaps-reload
-                             yas-minor-mode-on
-                             yas-load-directory
-                             yas-reload-all
-                             yas-compile-directory
-                             yas-recompile-all
-                             yas-about
-                             yas-expand-from-trigger-key
-                             yas-expand-from-keymap
-                             yas-insert-snippet
-                             yas-visit-snippet-file
-                             yas-new-snippet
-                             yas-load-snippet-buffer
-                             yas-tryout-snippet
-                             yas-describe-tables
-                             yas-next-field-or-maybe-expand
-                             yas-next-field
-                             yas-prev-field
-                             yas-abort-snippet
-                             yas-exit-snippet
-                             yas-exit-all-snippets
-                             yas-skip-and-clear-or-delete-char
-                             yas-initialize
-
-                             ;; symbols that I "exported" for use
-                             ;; in snippets and hookage
-                             ;;
-                             yas-expand-snippet
-                             yas-define-snippets
-                             yas-define-menu
-                             yas-snippet-beg
-                             yas-snippet-end
-                             yas-modified-p
-                             yas-moving-away-p
-                             yas-substr
-                             yas-choose-value
-                             yas-key-to-value
-                             yas-throw
-                             yas-verify-value
-                             yas-field-value
-                             yas-text
-                             yas-selected-text
-                             yas-default-from-field
-                             yas-inside-string
-                             yas-unimplemented
-                             yas-define-condition-cache
-                             yas-hippie-try-expand
-
-                             ;; debug definitions
-                             ;; yas-debug-snippet-vars
-                             ;; yas-exterminate-package
-                             ;; yas-debug-test
-
-                             ;; testing definitions
-                             ;; yas-should-expand
-                             ;; yas-should-not-expand
-                             ;; yas-mock-insert
-                             ;; yas-make-file-or-dirs
-                             ;; yas-variables
-                             ;; yas-saving-variables
-                             ;; yas-call-with-snippet-dirs
-                             ;; yas-with-snippet-dirs
-)
-  "Backported yasnippet symbols.
-
-They are mapped to \"yas/*\" variants.")
-
-(when yas-alias-to-yas/prefix-p
-  (dolist (sym yas--backported-syms)
-    (let ((backported (intern (replace-regexp-in-string "\\`yas-" "yas/" (symbol-name sym)))))
-      (when (boundp sym)
-        (make-obsolete-variable backported sym "yasnippet 0.8")
-        (defvaralias backported sym))
-      (when (fboundp sym)
-        (make-obsolete backported sym "yasnippet 0.8")
-        (defalias backported sym))))
-  (make-obsolete 'yas/root-directory 'yas-snippet-dirs "yasnippet 0.8")
-  (defvaralias 'yas/root-directory 'yas-snippet-dirs))
-
-(defvar yas--exported-syms
-  (let (exported)
-    (mapatoms (lambda (atom)
-                (if (and (or (and (boundp atom)
-                                  (not (get atom 'byte-obsolete-variable)))
-                             (and (fboundp atom)
-                                  (not (get atom 'byte-obsolete-info))))
-                         (string-match-p "\\`yas-[^-]" (symbol-name atom)))
-                    (push atom exported))))
-    exported)
-  "Exported yasnippet symbols.
-
-i.e. the ones with \"yas-\" single dash prefix. I will try to
-keep them in future yasnippet versions and other elisp libraries
-can more or less safely rely upon them.")
-
-
-(provide 'yasnippet)
-;; Local Variables:
-;; coding: utf-8
-;; indent-tabs-mode: nil
-;; End:
-;;; yasnippet.el ends here
diff --git a/configs/shared/emacs/.emacs.d/elpa/yasnippet-20180621.50/yasnippet.elc b/configs/shared/emacs/.emacs.d/elpa/yasnippet-20180621.50/yasnippet.elc
deleted file mode 100644
index a370692a5126..000000000000
--- a/configs/shared/emacs/.emacs.d/elpa/yasnippet-20180621.50/yasnippet.elc
+++ /dev/null
Binary files differ