diff --git a/elpa/ag-20190726.9/ag-autoloads.el b/elpa/ag-20190726.9/ag-autoloads.el
deleted file mode 100644
index e7cc3a30..00000000
--- a/elpa/ag-20190726.9/ag-autoloads.el
+++ /dev/null
@@ -1,128 +0,0 @@
-;;; ag-autoloads.el --- automatically extracted autoloads
-;;
-;;; Code:
-
-(add-to-list 'load-path (directory-file-name
-                         (or (file-name-directory #$) (car load-path))))
-
-
-;;;### (autoloads nil "ag" "ag.el" (0 0 0 0))
-;;; Generated autoloads from ag.el
-
-(autoload 'ag "ag" "\
-Search using ag in a given DIRECTORY for a given literal search STRING,
-with STRING defaulting to the symbol under point.
-
-If called with a prefix, prompts for flags to pass to ag.
-
-\(fn STRING DIRECTORY)" t nil)
-
-(autoload 'ag-files "ag" "\
-Search using ag in a given DIRECTORY for a given literal search STRING,
-limited to files that match FILE-TYPE. STRING defaults to the
-symbol under point.
-
-If called with a prefix, prompts for flags to pass to ag.
-
-\(fn STRING FILE-TYPE DIRECTORY)" t nil)
-
-(autoload 'ag-regexp "ag" "\
-Search using ag in a given directory for a given regexp.
-The regexp should be in PCRE syntax, not Emacs regexp syntax.
-
-If called with a prefix, prompts for flags to pass to ag.
-
-\(fn STRING DIRECTORY)" t nil)
-
-(autoload 'ag-project "ag" "\
-Guess the root of the current project and search it with ag
-for the given literal search STRING.
-
-If called with a prefix, prompts for flags to pass to ag.
-
-\(fn STRING)" t nil)
-
-(autoload 'ag-project-files "ag" "\
-Search using ag for a given literal search STRING,
-limited to files that match FILE-TYPE. STRING defaults to the
-symbol under point.
-
-If called with a prefix, prompts for flags to pass to ag.
-
-\(fn STRING FILE-TYPE)" t nil)
-
-(autoload 'ag-project-regexp "ag" "\
-Guess the root of the current project and search it with ag
-for the given regexp. The regexp should be in PCRE syntax, not
-Emacs regexp syntax.
-
-If called with a prefix, prompts for flags to pass to ag.
-
-\(fn REGEXP)" t nil)
-
-(defalias 'ag-project-at-point 'ag-project)
-
-(defalias 'ag-regexp-project-at-point 'ag-project-regexp)
-
-(autoload 'ag-dired "ag" "\
-Recursively find files in DIR matching literal search STRING.
-
-The PATTERN is matched against the full path to the file, not
-only against the file name.
-
-The results are presented as a `dired-mode' buffer with
-`default-directory' being DIR.
-
-See also `ag-dired-regexp'.
-
-\(fn DIR STRING)" t nil)
-
-(autoload 'ag-dired-regexp "ag" "\
-Recursively find files in DIR matching REGEXP.
-REGEXP should be in PCRE syntax, not Emacs regexp syntax.
-
-The REGEXP is matched against the full path to the file, not
-only against the file name.
-
-Results are presented as a `dired-mode' buffer with
-`default-directory' being DIR.
-
-See also `find-dired'.
-
-\(fn DIR REGEXP)" t nil)
-
-(autoload 'ag-project-dired "ag" "\
-Recursively find files in current project matching PATTERN.
-
-See also `ag-dired'.
-
-\(fn PATTERN)" t nil)
-
-(autoload 'ag-project-dired-regexp "ag" "\
-Recursively find files in current project matching REGEXP.
-
-See also `ag-dired-regexp'.
-
-\(fn REGEXP)" t nil)
-
-(autoload 'ag-kill-buffers "ag" "\
-Kill all `ag-mode' buffers.
-
-\(fn)" t nil)
-
-(autoload 'ag-kill-other-buffers "ag" "\
-Kill all `ag-mode' buffers other than the current buffer.
-
-\(fn)" t nil)
-
-(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "ag" '("ag-" "ag/")))
-
-;;;***
-
-;; Local Variables:
-;; version-control: never
-;; no-byte-compile: t
-;; no-update-autoloads: t
-;; coding: utf-8
-;; End:
-;;; ag-autoloads.el ends here
diff --git a/elpa/ag-20190726.9/ag-pkg.el b/elpa/ag-20190726.9/ag-pkg.el
deleted file mode 100644
index 013aa250..00000000
--- a/elpa/ag-20190726.9/ag-pkg.el
+++ /dev/null
@@ -1,2 +0,0 @@
-;;; -*- no-byte-compile: t -*-
-(define-package "ag" "20190726.9" "A front-end for ag ('the silver searcher'), the C ack replacement." '((dash "2.8.0") (s "1.9.0") (cl-lib "0.5")) :commit "bd81d68466e44301505629454dfc689b6c17d94b" :authors '(("Wilfred Hughes" . "me@wilfred.me.uk")) :maintainer '("Wilfred Hughes" . "me@wilfred.me.uk"))
diff --git a/elpa/ag-20190726.9/ag.el b/elpa/ag-20190726.9/ag.el
deleted file mode 100644
index 98d7f647..00000000
--- a/elpa/ag-20190726.9/ag.el
+++ /dev/null
@@ -1,689 +0,0 @@
-;;; ag.el --- A front-end for ag ('the silver searcher'), the C ack replacement.
-
-;; Copyright (C) 2013-2014 Wilfred Hughes <me@wilfred.me.uk>
-;;
-;; Author: Wilfred Hughes <me@wilfred.me.uk>
-;; Created: 11 January 2013
-;; Version: 0.48
-;; Package-Version: 20190726.9
-;; Package-Requires: ((dash "2.8.0") (s "1.9.0") (cl-lib "0.5"))
-;;; Commentary:
-
-;; Please see README.md for documentation, or read it online at
-;; https://github.com/Wilfred/ag.el/#agel
-
-;;; License:
-
-;; This file is not part of GNU Emacs.
-;; However, it is distributed under the same license.
-
-;; GNU Emacs is free software; you can redistribute it and/or modify
-;; it under the terms of the GNU General Public License as published by
-;; the Free Software Foundation; either version 3, or (at your option)
-;; any later version.
-
-;; GNU Emacs is distributed in the hope that it will be useful,
-;; but WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-;; GNU General Public License for more details.
-
-;; You should have received a copy of the GNU General Public License
-;; along with GNU Emacs; see the file COPYING.  If not, write to the
-;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
-;; Boston, MA 02110-1301, USA.
-
-;;; Code:
-(require 'cl-lib) ;; cl-letf, cl-defun
-(require 'dired) ;; dired-sort-inhibit
-(require 'dash)
-(require 's)
-(require 'find-dired) ;; find-dired-filter
-
-(defgroup ag nil
-  "A front-end for ag - The Silver Searcher."
-  :group 'tools
-  :group 'matching)
-
-(defcustom ag-executable
-  "ag"
-  "Name of the ag executable to use."
-  :type 'string
-  :group 'ag)
-
-(defcustom ag-arguments
-  (list "--smart-case" "--stats")
-  "Additional arguments passed to ag.
-
-Ag.el internally uses --column, --line-number and --color
-options (with specific colors) to match groups, so options
-specified here should not conflict.
-
---line-number is required on Windows, as otherwise ag will not
-print line numbers when the input is a stream."
-  :type '(repeat (string))
-  :group 'ag)
-
-(defcustom ag-dired-arguments
-  (list "--nocolor" "-S")
-  "Additional arguments passed to ag-dired."
-  :type '(repeat (string))
-  :group 'ag)
-
-(defcustom ag-context-lines nil
-  "Number of context lines to include before and after a matching line."
-  :type 'integer
-  :group 'ag)
-
-(defcustom ag-group-matches t
-  "Group matches in the same file together.
-
-If nil, the file name is repeated at the beginning of every match line."
-  :type 'boolean
-  :group 'ag)
-
-(defcustom ag-highlight-search nil
-  "Non-nil means we highlight the current search term in results.
-
-This requires the ag command to support --color-match, which is only in v0.14+"
-  :type 'boolean
-  :group 'ag)
-
-(defcustom ag-reuse-buffers nil
-  "Non-nil means we reuse the existing search results buffer or
-dired results buffer, rather than creating one buffer per unique
-search."
-  :type 'boolean
-  :group 'ag)
-
-(defcustom ag-reuse-window nil
-  "Non-nil means we open search results in the same window,
-hiding the results buffer."
-  :type 'boolean
-  :group 'ag)
-
-(defcustom ag-project-root-function nil
-  "A function to determine the project root for `ag-project'.
-
-If set to a function, call this function with the name of the
-file or directory for which to determine the project root
-directory.
-
-If set to nil, fall back to finding VCS root directories."
-  :type '(choice (const :tag "Default (VCS root)" nil)
-                 (function :tag "Function"))
-  :group 'ag)
-
-(defcustom ag-ignore-list nil
-  "A list of patterns for files/directories to ignore when searching."
-  :type '(repeat (string))
-  :group 'ag)
-(make-variable-buffer-local 'ag-ignore-list)
-(put 'ag-ignore-list 'safe-local-variable #'listp)
-
-(require 'compile)
-
-;; Although ag results aren't exactly errors, we treat them as errors
-;; so `next-error' and `previous-error' work. However, we ensure our
-;; face inherits from `compilation-info-face' so the results are
-;; styled appropriately.
-(defface ag-hit-face '((t :inherit compilation-info))
-  "Face name to use for ag matches."
-  :group 'ag)
-
-(defface ag-match-face '((t :inherit match))
-  "Face name to use for ag matches."
-  :group 'ag)
-
-(defvar ag-search-finished-hook nil
-  "Hook run when ag completes a search in a buffer.")
-
-(defun ag/run-finished-hook (buffer how-finished)
-  "Run the ag hook to signal that the search has completed."
-  (with-current-buffer buffer
-    (run-hooks 'ag-search-finished-hook)))
-
-(defmacro ag/with-patch-function (fun-name fun-args fun-body &rest body)
-  "Temporarily override the definition of FUN-NAME whilst BODY is executed.
-
-Assumes FUNCTION is already defined (see http://emacs.stackexchange.com/a/3452/304)."
-  `(cl-letf (((symbol-function ,fun-name)
-              (lambda ,fun-args ,fun-body)))
-     ,@body))
-
-(defun ag/next-error-function (n &optional reset)
-  "Open the search result at point in the current window or a
-different window, according to `ag-reuse-window'."
-  (if ag-reuse-window
-      ;; prevent changing the window
-      (ag/with-patch-function
-       'pop-to-buffer (buffer &rest args) (switch-to-buffer buffer)
-       (compilation-next-error-function n reset))
-
-    ;; just navigate to the results as normal
-    (compilation-next-error-function n reset)))
-
-;; Note that we want to use as tight a regexp as we can to try and
-;; handle weird file names (with colons in them) as well as possible.
-;; E.g. we use [1-9][0-9]* rather than [0-9]+ so as to accept ":034:"
-;; in file names.
-(defvar ag/file-column-pattern-nogroup
-  "^\\(.+?\\):\\([1-9][0-9]*\\):\\([1-9][0-9]*\\):"
-  "A regexp pattern that groups output into filename, line number and column number.")
-
-(defvar ag/file-column-pattern-group
-  "^\\([[:digit:]]+\\):\\([[:digit:]]+\\):"
-  "A regexp pattern to match line number and column number with grouped output.")
-
-(defun ag/compilation-match-grouped-filename ()
-  "Match filename backwards when a line/column match is found in grouped output mode."
-  (save-match-data
-    (save-excursion
-      (when (re-search-backward "^File: \\(.*\\)$" (point-min) t)
-        (list (match-string 1))))))
-
-(define-compilation-mode ag-mode "Ag"
-  "Ag results compilation mode"
-  (set (make-local-variable 'compilation-error-regexp-alist)
-       '(compilation-ag-nogroup compilation-ag-group))
-  (set (make-local-variable 'compilation-error-regexp-alist-alist)
-       (list (cons 'compilation-ag-nogroup  (list ag/file-column-pattern-nogroup 1 2 3))
-             (cons 'compilation-ag-group  (list ag/file-column-pattern-group
-                                                'ag/compilation-match-grouped-filename 1 2))))
-  (set (make-local-variable 'compilation-error-face) 'ag-hit-face)
-  (set (make-local-variable 'next-error-function) #'ag/next-error-function)
-  (set (make-local-variable 'compilation-finish-functions)
-       #'ag/run-finished-hook)
-  (add-hook 'compilation-filter-hook 'ag-filter nil t))
-
-(define-key ag-mode-map (kbd "p") #'compilation-previous-error)
-(define-key ag-mode-map (kbd "n") #'compilation-next-error)
-(define-key ag-mode-map (kbd "k") '(lambda () (interactive)
-                                     (let (kill-buffer-query-functions) (kill-buffer))))
-
-(defun ag/buffer-name (search-string directory regexp)
-  "Return a buffer name formatted according to ag.el conventions."
-  (cond
-   (ag-reuse-buffers "*ag search*")
-   (regexp (format "*ag search regexp:%s dir:%s*" search-string directory))
-   (:else (format "*ag search text:%s dir:%s*" search-string directory))))
-
-(defun ag/format-ignore (ignores)
-  "Prepend '--ignore' to every item in IGNORES."
-  (apply #'append
-         (mapcar (lambda (item) (list "--ignore" item)) ignores)))
-
-(cl-defun ag/search (string directory
-                            &key (regexp nil) (file-regex nil) (file-type nil) (files '(".")))
-  "Run ag searching for the STRING given in DIRECTORY.
-If `files` is passed, tell ag to look only on those files.
-If REGEXP is non-nil, treat STRING as a regular expression."
-  (let ((default-directory (file-name-as-directory directory))
-        (arguments ag-arguments)
-        (shell-command-switch "-c"))
-    ;; Add double dashes at the end of command line if not specified in
-    ;; ag-arguments.
-    (unless (equal (car (last arguments)) "--")
-      (setq arguments (append arguments '("--"))))
-    (setq arguments
-          (append '("--line-number" "--column" "--color" "--color-match" "30;43"
-                    "--color-path" "1;32")
-                  arguments))
-    (if ag-group-matches
-        (setq arguments (cons "--group" arguments))
-      (setq arguments (cons "--nogroup" arguments)))
-    (unless regexp
-      (setq arguments (cons "--literal" arguments)))
-    (when (or (eq system-type 'windows-nt) (eq system-type 'cygwin))
-      ;; Use --vimgrep to work around issue #97 on Windows.
-      (setq arguments (cons "--vimgrep" arguments)))
-    (when (char-or-string-p file-regex)
-      (setq arguments (append `("--file-search-regex" ,file-regex) arguments)))
-    (when file-type
-      (setq arguments (cons (format "--%s" file-type) arguments)))
-    (if (integerp current-prefix-arg)
-        (setq arguments (cons (format "--context=%d" (abs current-prefix-arg)) arguments))
-      (when ag-context-lines
-        (setq arguments (cons (format "--context=%d" ag-context-lines) arguments))))
-    (when ag-ignore-list
-      (setq arguments (append (ag/format-ignore ag-ignore-list) arguments)))
-    (unless (file-exists-p default-directory)
-      (error "No such directory %s" default-directory))
-    (let ((command-string
-           (mapconcat #'shell-quote-argument
-                      (append (list ag-executable) arguments (append `(,string) files))
-                      " ")))
-      ;; If we're called with a prefix, let the user modify the command before
-      ;; running it. Typically this means they want to pass additional arguments.
-      ;; The numeric value is used for context lines: positive is just context
-      ;; number (no modification), negative allows further modification.
-      (when (and current-prefix-arg (not (and (integerp current-prefix-arg) (> current-prefix-arg 0))))
-        ;; Make a space in the command-string for the user to enter more arguments.
-        (setq command-string (ag/replace-first command-string " -- " "  -- "))
-        ;; Prompt for the command.
-        (let ((adjusted-point (- (length command-string) (length string) 5)))
-          (setq command-string
-                (read-from-minibuffer "ag command: "
-                                      (cons command-string adjusted-point)))))
-      ;; Call ag.
-      (compilation-start
-       command-string
-       #'ag-mode
-       `(lambda (mode-name) ,(ag/buffer-name string directory regexp))))))
-
-(defun ag/dwim-at-point ()
-  "If there's an active selection, return that.
-Otherwise, get the symbol at point, as a string."
-  (cond ((use-region-p)
-         (buffer-substring-no-properties (region-beginning) (region-end)))
-        ((symbol-at-point)
-         (substring-no-properties
-          (symbol-name (symbol-at-point))))))
-
-(defun ag/buffer-extension-regex ()
-  "If the current buffer has an extension, return
-a PCRE pattern that matches files with that extension.
-Returns an empty string otherwise."
-  (let ((file-name (buffer-file-name)))
-    (if (stringp file-name)
-        (format "\\.%s$" (ag/escape-pcre (file-name-extension file-name)))
-      "")))
-
-(defun ag/longest-string (&rest strings)
-  "Given a list of strings and nils, return the longest string."
-  (let ((longest-string nil))
-    (dolist (string (-non-nil strings))
-      (when (< (length longest-string)
-               (length string))
-        (setq longest-string string)))
-    longest-string))
-
-(defun ag/replace-first (string before after)
-  "Replace the first occurrence of BEFORE in STRING with AFTER."
-  (replace-regexp-in-string
-   (concat "\\(" (regexp-quote before) "\\)" ".*\\'")
-   after string
-   nil nil 1))
-
-(autoload 'vc-git-root "vc-git")
-
-(require 'vc-svn)
-;; Emacs 23.4 doesn't provide vc-svn-root.
-(unless (functionp 'vc-svn-root)
-  (defun vc-svn-root (file)
-    (vc-find-root file vc-svn-admin-directory)))
-
-(autoload 'vc-hg-root "vc-hg")
-
-(autoload 'vc-bzr-root "vc-bzr")
-
-(defun ag/project-root (file-path)
-  "Guess the project root of the given FILE-PATH.
-
-Use `ag-project-root-function' if set, or fall back to VCS
-roots."
-  (if ag-project-root-function
-      (funcall ag-project-root-function file-path)
-    (or (ag/longest-string
-       (vc-git-root file-path)
-       (vc-svn-root file-path)
-       (vc-hg-root file-path)
-       (vc-bzr-root file-path))
-      file-path)))
-
-(defun ag/dired-align-size-column ()
-  (beginning-of-line)
-  (when (looking-at "^  ")
-    (forward-char 2)
-    (search-forward " " nil t 4)
-    (let* ((size-start (point))
-           (size-end (search-forward " " nil t))
-           (width (and size-end (- size-end size-start))))
-      (when (and size-end
-                 (< width 12)
-                 (> width 1))
-        (goto-char size-start)
-        (insert (make-string (- 12 width) ? ))))))
-
-(defun ag/dired-filter (proc string)
-  "Filter the output of ag to make it suitable for `dired-mode'."
-  (let ((buf (process-buffer proc))
-        (inhibit-read-only t))
-    (if (buffer-name buf)
-        (with-current-buffer buf
-          (save-excursion
-            (save-restriction
-              (widen)
-              (let ((beg (point-max)))
-                (goto-char beg)
-                (insert string)
-                (goto-char beg)
-                (or (looking-at "^")
-                    (progn
-                      (ag/dired-align-size-column)
-                      (forward-line 1)))
-                (while (looking-at "^")
-                  (insert "  ")
-                  (ag/dired-align-size-column)
-                  (forward-line 1))
-                (goto-char beg)
-                (beginning-of-line)
-
-                ;; Remove occurrences of default-directory.
-                (while (search-forward (concat " " default-directory) nil t)
-                  (replace-match " " nil t))
-
-                (goto-char (point-max))
-                (if (search-backward "\n" (process-mark proc) t)
-                    (progn
-                      (dired-insert-set-properties (process-mark proc)
-                                                   (1+ (point)))
-                      (move-marker (process-mark proc) (1+ (point)))))))))
-      (delete-process proc))))
-
-(defun ag/dired-sentinel (proc state)
-  "Update the status/modeline after the process finishes."
-  (let ((buf (process-buffer proc))
-        (inhibit-read-only t))
-    (if (buffer-name buf)
-        (with-current-buffer buf
-          (let ((buffer-read-only nil))
-            (save-excursion
-              (goto-char (point-max))
-              (insert "\n  ag " state)
-              (forward-char -1)     ;Back up before \n at end of STATE.
-              (insert " at " (substring (current-time-string) 0 19))
-              (forward-char 1)
-              (setq mode-line-process
-                    (concat ":" (symbol-name (process-status proc))))
-              ;; Since the buffer and mode line will show that the
-              ;; process is dead, we can delete it now.  Otherwise it
-              ;; will stay around until M-x list-processes.
-              (delete-process proc)
-              (force-mode-line-update)))
-          (run-hooks 'dired-after-readin-hook)
-          (message "%s finished." (current-buffer))))))
-
-(defun ag/kill-process ()
-  "Kill the `ag' process running in the current buffer."
-  (interactive)
-  (let ((ag (get-buffer-process (current-buffer))))
-    (and ag (eq (process-status ag) 'run)
-         (eq (process-filter ag) (function find-dired-filter))
-         (condition-case nil
-             (delete-process ag)
-           (error nil)))))
-
-(defun ag/escape-pcre (regexp)
-  "Escape the PCRE-special characters in REGEXP so that it is
-matched literally."
-  (let ((alphanum "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"))
-    (apply #'concat
-           (mapcar
-            (lambda (c)
-              (cond
-               ((not (string-match-p (regexp-quote c) alphanum))
-                (concat "\\" c))
-               (t c)))
-            (mapcar #'char-to-string (string-to-list regexp))))))
-
-;;;###autoload
-(defun ag (string directory)
-  "Search using ag in a given DIRECTORY for a given literal search STRING,
-with STRING defaulting to the symbol under point.
-
-If called with a prefix, prompts for flags to pass to ag."
-  (interactive (list (ag/read-from-minibuffer "Search string")
-                     (read-directory-name "Directory: ")))
-  (ag/search string directory))
-
-;;;###autoload
-(defun ag-files (string file-type directory)
-  "Search using ag in a given DIRECTORY for a given literal search STRING,
-limited to files that match FILE-TYPE. STRING defaults to the
-symbol under point.
-
-If called with a prefix, prompts for flags to pass to ag."
-  (interactive (list (ag/read-from-minibuffer "Search string")
-                     (ag/read-file-type)
-                     (read-directory-name "Directory: ")))
-  (apply #'ag/search string directory file-type))
-
-;;;###autoload
-(defun ag-regexp (string directory)
-  "Search using ag in a given directory for a given regexp.
-The regexp should be in PCRE syntax, not Emacs regexp syntax.
-
-If called with a prefix, prompts for flags to pass to ag."
-  (interactive "sSearch regexp: \nDDirectory: ")
-  (ag/search string directory :regexp t))
-
-;;;###autoload
-(defun ag-project (string)
-  "Guess the root of the current project and search it with ag
-for the given literal search STRING.
-
-If called with a prefix, prompts for flags to pass to ag."
-  (interactive (list (ag/read-from-minibuffer "Search string")))
-  (ag/search string (ag/project-root default-directory)))
-
-;;;###autoload
-(defun ag-project-files (string file-type)
-  "Search using ag for a given literal search STRING,
-limited to files that match FILE-TYPE. STRING defaults to the
-symbol under point.
-
-If called with a prefix, prompts for flags to pass to ag."
-  (interactive (list (ag/read-from-minibuffer "Search string")
-                     (ag/read-file-type)))
-  (apply 'ag/search string (ag/project-root default-directory) file-type))
-
-(defun ag/read-from-minibuffer (prompt)
-  "Read a value from the minibuffer with PROMPT.
-If there's a string at point, offer that as a default."
-  (let* ((suggested (ag/dwim-at-point))
-         (final-prompt
-          (if suggested
-              (format "%s (default %s): " prompt suggested)
-            (format "%s: " prompt)))
-         ;; Ask the user for input, but add `suggested' to the history
-         ;; so they can use M-n if they want to modify it.
-         (user-input (read-from-minibuffer
-                      final-prompt
-                      nil nil nil nil suggested)))
-    ;; Return the input provided by the user, or use `suggested' if
-    ;; the input was empty.
-    (if (> (length user-input) 0)
-        user-input
-      suggested)))
-
-;;;###autoload
-(defun ag-project-regexp (regexp)
-  "Guess the root of the current project and search it with ag
-for the given regexp. The regexp should be in PCRE syntax, not
-Emacs regexp syntax.
-
-If called with a prefix, prompts for flags to pass to ag."
-  (interactive (list (ag/read-from-minibuffer "Search regexp")))
-  (ag/search regexp (ag/project-root default-directory) :regexp t))
-
-(autoload 'symbol-at-point "thingatpt")
-
-;;;###autoload
-(defalias 'ag-project-at-point 'ag-project)
-(make-obsolete 'ag-project-at-point 'ag-project "0.19")
-
-;;;###autoload
-(defalias 'ag-regexp-project-at-point 'ag-project-regexp)
-(make-obsolete 'ag-regexp-project-at-point 'ag-project-regexp "0.46")
-
-;;;###autoload
-(defun ag-dired (dir string)
-  "Recursively find files in DIR matching literal search STRING.
-
-The PATTERN is matched against the full path to the file, not
-only against the file name.
-
-The results are presented as a `dired-mode' buffer with
-`default-directory' being DIR.
-
-See also `ag-dired-regexp'."
-  (interactive "DDirectory: \nsFile pattern: ")
-  (ag-dired-regexp dir (ag/escape-pcre string)))
-
-;;;###autoload
-(defun ag-dired-regexp (dir regexp)
-  "Recursively find files in DIR matching REGEXP.
-REGEXP should be in PCRE syntax, not Emacs regexp syntax.
-
-The REGEXP is matched against the full path to the file, not
-only against the file name.
-
-Results are presented as a `dired-mode' buffer with
-`default-directory' being DIR.
-
-See also `find-dired'."
-  (interactive "DDirectory: \nsFile regexp: ")
-  (let* ((dired-buffers dired-buffers) ;; do not mess with regular dired buffers
-         (orig-dir dir)
-         (dir (file-name-as-directory (expand-file-name dir)))
-         (buffer-name (if ag-reuse-buffers
-                          "*ag dired*"
-                        (format "*ag dired pattern:%s dir:%s*" regexp dir)))
-         (cmd (if (string= system-type "windows-nt")
-                  (concat ag-executable " " (combine-and-quote-strings ag-dired-arguments " ") " -g \"" regexp "\" "
-                          (shell-quote-argument dir)
-                          " | grep -v \"^$\" | sed \"s/'/\\\\\\\\'/g\" | xargs -I '{}' "
-                          insert-directory-program " "
-                          dired-listing-switches " '{}' &")
-                (concat ag-executable " " (combine-and-quote-strings ag-dired-arguments " ") " -g '" regexp "' "
-                        (shell-quote-argument dir)
-                        " | grep -v '^$' | sed s/\\'/\\\\\\\\\\'/g | xargs -I '{}' "
-                        insert-directory-program " "
-                        dired-listing-switches " '{}' &"))))
-    (with-current-buffer (get-buffer-create buffer-name)
-      (switch-to-buffer (current-buffer))
-      (widen)
-      (kill-all-local-variables)
-      (if (fboundp 'read-only-mode)
-          (read-only-mode -1)
-        (setq buffer-read-only nil))
-      (let ((inhibit-read-only t)) (erase-buffer))
-      (setq default-directory dir)
-      (run-hooks 'dired-before-readin-hook)
-      (shell-command cmd (current-buffer))
-      (insert "  " dir ":\n")
-      (insert "  " cmd "\n")
-      (dired-mode dir)
-      (let ((map (make-sparse-keymap)))
-        (set-keymap-parent map (current-local-map))
-        (define-key map "\C-c\C-k" 'ag/kill-process)
-        (use-local-map map))
-      (set (make-local-variable 'dired-sort-inhibit) t)
-      (set (make-local-variable 'revert-buffer-function)
-           `(lambda (ignore-auto noconfirm)
-              (ag-dired-regexp ,orig-dir ,regexp)))
-      (if (fboundp 'dired-simple-subdir-alist)
-          (dired-simple-subdir-alist)
-        (set (make-local-variable 'dired-subdir-alist)
-             (list (cons default-directory (point-min-marker)))))
-      (let ((proc (get-buffer-process (current-buffer))))
-        (set-process-filter proc #'ag/dired-filter)
-        (set-process-sentinel proc #'ag/dired-sentinel)
-        ;; Initialize the process marker; it is used by the filter.
-        (move-marker (process-mark proc) 1 (current-buffer)))
-      (setq mode-line-process '(":%s")))))
-
-;;;###autoload
-(defun ag-project-dired (pattern)
-  "Recursively find files in current project matching PATTERN.
-
-See also `ag-dired'."
-  (interactive "sFile pattern: ")
-  (ag-dired-regexp (ag/project-root default-directory) (ag/escape-pcre pattern)))
-
-;;;###autoload
-(defun ag-project-dired-regexp (regexp)
-  "Recursively find files in current project matching REGEXP.
-
-See also `ag-dired-regexp'."
-  (interactive "sFile regexp: ")
-  (ag-dired-regexp (ag/project-root default-directory) regexp))
-
-;;;###autoload
-(defun ag-kill-buffers ()
-  "Kill all `ag-mode' buffers."
-  (interactive)
-  (dolist (buffer (buffer-list))
-    (when (eq (buffer-local-value 'major-mode buffer) 'ag-mode)
-      (kill-buffer buffer))))
-
-;;;###autoload
-(defun ag-kill-other-buffers ()
-  "Kill all `ag-mode' buffers other than the current buffer."
-  (interactive)
-  (let ((current-buffer (current-buffer)))
-    (dolist (buffer (buffer-list))
-      (when (and
-             (eq (buffer-local-value 'major-mode buffer) 'ag-mode)
-             (not (eq buffer current-buffer)))
-        (kill-buffer buffer)))))
-
-;; Based on grep-filter.
-(defun ag-filter ()
-  "Handle escape sequences inserted by the ag process.
-This function is called from `compilation-filter-hook'."
-  (save-excursion
-    (forward-line 0)
-    (let ((end (point)) beg)
-      (goto-char compilation-filter-start)
-      (forward-line 0)
-      (setq beg (point))
-      ;; Only operate on whole lines so we don't get caught with part of an
-      ;; escape sequence in one chunk and the rest in another.
-      (when (< (point) end)
-        (setq end (copy-marker end))
-        (when ag-highlight-search
-          ;; Highlight ag matches and delete marking sequences.
-          (while (re-search-forward "\033\\[30;43m\\(.*?\\)\033\\[0m\033\\[K" end 1)
-            (replace-match (propertize (match-string 1)
-                                       'face nil 'font-lock-face 'ag-match-face)
-                           t t)))
-        ;; Add marker at start of line for files. This is used by the match
-        ;; in `compilation-error-regexp-alist' to extract the file name.
-        (when ag-group-matches
-          (goto-char beg)
-          (while (re-search-forward "\033\\[1;32m\\(.*\\)\033\\[0m\033\\[K" end 1)
-            (replace-match
-             (concat "File: " (propertize (match-string 1) 'face nil 'font-lock-face
-                                          'compilation-info))
-             t t)))
-        ;; Delete all remaining escape sequences
-        (goto-char beg)
-        (while (re-search-forward "\033\\[[0-9;]*[mK]" end 1)
-          (replace-match "" t t))))))
-
-(defun ag/get-supported-types ()
-  "Query the ag executable for which file types it recognises."
-  (let* ((ag-output (shell-command-to-string (format "%s --list-file-types" ag-executable)))
-         (lines (-map #'s-trim (s-lines ag-output)))
-         (types (--keep (when (s-starts-with? "--" it) (s-chop-prefix "--" it )) lines))
-         (extensions (--map (s-split "  " it) (--filter (s-starts-with? "." it) lines))))
-    (-zip types extensions)))
-
-(defun ag/read-file-type ()
-  "Prompt the user for a known file type, or let them specify a PCRE regex."
-  (let* ((all-types-with-extensions (ag/get-supported-types))
-         (all-types (mapcar 'car all-types-with-extensions))
-         (file-type
-          (completing-read "Select file type: "
-                           (append '("custom (provide a PCRE regex)") all-types)))
-         (file-type-extensions
-          (cdr (assoc file-type all-types-with-extensions))))
-    (if file-type-extensions
-        (list :file-type file-type)
-      (list :file-regex
-            (read-from-minibuffer "Filenames which match PCRE: "
-                                  (ag/buffer-extension-regex))))))
-
-(provide 'ag)
-;;; ag.el ends here
diff --git a/elpa/ag-20190726.9/ag.elc b/elpa/ag-20190726.9/ag.elc
deleted file mode 100644
index 6a1e370e..00000000
Binary files a/elpa/ag-20190726.9/ag.elc and /dev/null differ
diff --git a/elpa/archives/gnu/archive-contents b/elpa/archives/gnu/archive-contents
index 24b25837..7fd4cf84 100644
--- a/elpa/archives/gnu/archive-contents
+++ b/elpa/archives/gnu/archive-contents
@@ -1173,7 +1173,7 @@
 	   (:maintainer "Alexey Veretennikov" . "alexey.veretennikov@gmail.com")
 	   (:url . "https://github.com/fourier/loccur"))])
  (map .
-      [(2 0)
+      [(2 1)
        ((emacs
 	 (25)))
        "Map manipulation functions" single
@@ -1411,7 +1411,7 @@
 	      (:maintainer "Michael Heerdegen" . "michael_heerdegen@web.de")
 	      (:url . "https://github.com/michael-heerdegen/on-screen.el"))])
  (org .
-      [(9 3 2)
+      [(9 3 3)
        nil "Outline-based notes management and organizer" tar
        ((:url . "https://orgmode.org")
 	(:maintainer "Bastien Guerry" . "bzg@gnu.org")
@@ -1543,11 +1543,11 @@
 	   ("Mario Lang" . "mlang@delysid.org"))
 	  (:maintainer "Mario Lang" . "mlang@delysid.org"))])
  (posframe .
-	   [(0 5 0)
+	   [(0 6 0)
 	    ((emacs
 	      (26)))
 	    "Pop a posframe (just a frame) at point" single
-	    ((:keywords "tooltip")
+	    ((:keywords "convenience" "tooltip")
 	     (:authors
 	      ("Feng Shu" . "tumashu@163.com"))
 	     (:maintainer "Feng Shu" . "tumashu@163.com")
diff --git a/elpa/archives/gnu/archive-contents.signed b/elpa/archives/gnu/archive-contents.signed
index 78bff843..3bd9b4a6 100644
--- a/elpa/archives/gnu/archive-contents.signed
+++ b/elpa/archives/gnu/archive-contents.signed
@@ -1 +1 @@
-Good signature from 066DAFCB81E42C40 GNU ELPA Signing Agent (2019) <elpasign@elpa.gnu.org> (trust undefined) created at 2020-01-29T11:05:03+0100 using RSA
\ No newline at end of file
+Good signature from 066DAFCB81E42C40 GNU ELPA Signing Agent (2019) <elpasign@elpa.gnu.org> (trust undefined) created at 2020-02-05T11:05:09+0100 using RSA
\ No newline at end of file
diff --git a/elpa/ein-20200202.218/ein-helm.el b/elpa/ein-20200202.218/ein-helm.el
deleted file mode 100644
index 65a5c632..00000000
--- a/elpa/ein-20200202.218/ein-helm.el
+++ /dev/null
@@ -1,173 +0,0 @@
-;;; ein-helm.el --- Helm/anything commands
-
-;; Copyright (C) 2012 Takafumi Arakaki
-
-;; Author: Takafumi Arakaki <aka.tkf at gmail.com>
-
-;; This file is NOT part of GNU Emacs.
-
-;; ein-helm.el 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.
-
-;; ein-helm.el 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 ein-helm.el.  If not, see <http://www.gnu.org/licenses/>.
-
-;;; Commentary:
-
-;;
-
-;;; Code:
-
-(declare-function anything-other-buffer "anything")
-(declare-function helm-other-buffer "helm")
-
-(require 'ein-kernel)
-
-
-;;; Macros
-
-(defmacro ein:helm-export-source (name)
-  (let* ((orig-source (intern (format "ein:helm-source-%s"        name)))
-         (any-source  (intern (format "anything-c-source-ein-%s" name)))
-         (helm-source (intern (format "helm-c-source-ein-%s"     name)))
-         (docstring (format "Alias to `%s'" orig-source)))
-    `(progn
-       (defvaralias ',helm-source ',orig-source ,docstring)
-       (defvaralias ',any-source  ',orig-source ,docstring))))
-
-
-;;; Dynamic Variables
-
-(defvar ein:helm-pattern 'helm-pattern
-  "Dynamically bound to one of `helm-pattern' or `anything-pattern'.")
-
-(defvar ein:helm-kernel nil
-  "Dynamically bound to a kernel object.")
-
-
-
-;;; History search
-
-(defcustom ein:helm-kernel-history-search-auto-pattern t
-  "Automatically construct search pattern when non-`nil'.
-
-1. Single space is converted to \"*\".
-2. A backslash followed by a space is converted to a single space.
-3. A \"*\" is added at the beginning and end of the pattern.
-
-This variable applies to both `helm-ein-kernel-history' and
-`anything-ein-kernel-history'."
-  :type 'boolean
-  :group 'ein)
-
-(defun ein:helm-kernel-history-search-construct-pattern (pattern)
-  (when ein:helm-kernel-history-search-auto-pattern
-    (setq pattern
-          (replace-regexp-in-string "[^\\\\ ]\\( \\)[^\\\\ ]"
-                                    "*" pattern nil nil 1))
-    (setq pattern
-          (replace-regexp-in-string "\\\\ " " " pattern))
-    (setq pattern (concat "*" pattern "*")))
-  pattern)
-
-(defun ein:helm-kernel-history-search-get-candidates ()
-  "Retrieve search result from kernel.
-It requires the following dynamical variables:
-* `ein:helm-pattern'
-* `ein:helm-kernel'"
-  (let* ((pattern (ein:helm-kernel-history-search-construct-pattern
-                   (eval ein:helm-pattern)))
-         (candidates (ein:kernel-history-search-synchronously
-                      ein:helm-kernel pattern :unique t)))
-    ;; Most recent history first:
-    (nreverse candidates)))
-
-(defvar ein:helm-source-kernel-history
-  '((name . "IPython history")
-    (candidates . ein:helm-kernel-history-search-get-candidates)
-    (requires-pattern . 3)
-    ;; There is no need to filter out candidates:
-    (match . (identity))
-    (volatile)
-    (action . insert)
-    (delayed)
-    (multiline))
-  "Helm/anything source for searching kernel history.")
-
-;;;###autoload
-(defun anything-ein-kernel-history ()
-  "Search kernel execution history then insert the selected one."
-  (interactive)
-  (let ((ein:helm-pattern 'anything-pattern)
-        (ein:helm-kernel (ein:get-kernel-or-error)))
-    (anything-other-buffer ein:helm-source-kernel-history "*anything ein*")))
-
-;;;###autoload
-(defun helm-ein-kernel-history ()
-  "Search kernel execution history then insert the selected one."
-  (interactive)
-  (let ((ein:helm-pattern 'helm-pattern)
-        (ein:helm-kernel (ein:get-kernel-or-error)))
-    (helm-other-buffer ein:helm-source-kernel-history "*helm ein*")))
-
-
-
-;;; Notebook buffers
-
-(defvar ein:helm-source-notebook-buffers
-  '((name . "All IPython notebook buffers")
-    (candidates . ein:notebook-opened-buffer-names)
-    (type . buffer))
-  "Helm/anything source for all opened notebook buffers.")
-
-(defvar ein:helm-source-modified-notebook-buffers
-  '((name . "Modified IPython notebook buffers")
-    (candidates
-     . (lambda ()
-         (ein:notebook-opened-buffer-names #'ein:notebook-modified-p)))
-    (type . buffer))
-  "Helm/anything source for modified notebook buffers.")
-
-(defvar ein:helm-source-saved-notebook-buffers
-  '((name . "Saved IPython notebook buffers")
-    (candidates
-     . (lambda ()
-         (ein:notebook-opened-buffer-names
-          (lambda (nb) (not (ein:notebook-modified-p nb))))))
-    (type . buffer))
-  "Helm/anything source for saved notebook buffers.")
-
-
-;;; "Export" sources to `helm/anything-c-source-*'
-(ein:helm-export-source notebook-buffers)
-(ein:helm-export-source modified-notebook-buffers)
-(ein:helm-export-source saved-notebook-buffers)
-
-
-;;; Helm/anything commands
-
-(defvar ein:helm-notebook-buffer-sources
-  '(ein:helm-source-modified-notebook-buffers
-    ein:helm-source-saved-notebook-buffers))
-
-;;;###autoload
-(defun anything-ein-notebook-buffers ()
-  "Choose opened notebook using anything.el interface."
-  (interactive)
-  (anything-other-buffer ein:helm-notebook-buffer-sources "*anything ein*"))
-
-;;;###autoload
-(defun helm-ein-notebook-buffers ()
-  "Choose opened notebook using helm interface."
-  (interactive)
-  (helm-other-buffer ein:helm-notebook-buffer-sources "*helm ein*"))
-
-(provide 'ein-helm)
-;;; ein-helm.el ends here
diff --git a/elpa/ein-20200202.218/ein-helm.elc b/elpa/ein-20200202.218/ein-helm.elc
deleted file mode 100644
index faea4cf9..00000000
Binary files a/elpa/ein-20200202.218/ein-helm.elc and /dev/null differ
diff --git a/elpa/ein-20200202.218/ein-pager.el b/elpa/ein-20200202.218/ein-pager.el
deleted file mode 100644
index 5c8daabd..00000000
--- a/elpa/ein-20200202.218/ein-pager.el
+++ /dev/null
@@ -1,98 +0,0 @@
-;;; ein-pager.el --- Pager module
-
-;; Copyright (C) 2012- Takafumi Arakaki
-
-;; Author: Takafumi Arakaki <aka.tkf at gmail.com>
-
-;; This file is NOT part of GNU Emacs.
-
-;; ein-pager.el 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.
-
-;; ein-pager.el 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 ein-pager.el.  If not, see <http://www.gnu.org/licenses/>.
-
-;;; Commentary:
-
-;;
-
-;;; Code:
-
-(require 'ansi-color)
-
-(require 'ein-core)
-(require 'ein-events)
-(require 'view)
-
-;; FIXME: Make a class with `:get-notebook-name' slot like `ein:worksheet'
-
-(declare-function ess-help-underline "ess-help")
-
-(defun ein:pager-new (name events)
-  ;; currently pager = name.
-  (ein:pager-bind-events name events)
-  name)
-
-(defun ein:pager-bind-events (pager events)
-  "Bind events related to PAGER to the event handler EVENTS."
-  (ein:events-on events
-                 'open_with_text.Pager
-                 #'ein:pager--open-with-text
-                 pager))
-
-(defun ein:pager--open-with-text (pager data)
-  (let ((text (plist-get data :text)))
-    (unless (equal (ein:trim text) "")
-      (ein:pager-clear pager)
-      (ein:pager-expand pager)
-      (ein:pager-append-text pager text))))
-
-(defun ein:pager-clear (pager)
-  (ein:with-read-only-buffer (get-buffer-create pager)
-    (erase-buffer)))
-
-(defun ein:pager-expand (pager)
-  (pop-to-buffer (get-buffer-create pager))
-  (goto-char (point-min)))
-
-(defun ein:pager-append-text (pager text)
-  (ein:with-read-only-buffer (get-buffer-create pager)
-    (insert (ansi-color-apply text))
-    (if (featurep 'ess-help)
-        (ess-help-underline))
-    (unless (eql 'ein:pager-mode major-mode)
-      (ein:pager-mode))))
-
-;; FIXME: this should be automatically called when opening pager.
-(defun ein:pager-goto-docstring-bset-loc ()
-  "Goto the best location of the documentation."
-  (interactive)
-  (goto-char (point-min))
-  (search-forward-regexp "^Docstring:")
-  (beginning-of-line 0)
-  (recenter 0))
-
-(defvar ein:pager-mode-map
-  (let ((map (make-sparse-keymap)))
-    (define-key map "\C-c\C-b" 'ein:pager-goto-docstring-bset-loc)
-    map)
-  "Keymap for ein:pager-mode.")
-
-(define-derived-mode ein:pager-mode view-mode "ein:pager"
-  "IPython notebook pager mode.
-Commands:
-\\{ein:pager-mode-map}"
-  (setq-local view-no-disable-on-exit t)
-  (font-lock-mode))
-
-
-(provide 'ein-pager)
-
-;;; ein-pager.el ends here
diff --git a/elpa/ein-20200202.218/ein-pager.elc b/elpa/ein-20200202.218/ein-pager.elc
deleted file mode 100644
index df1596cc..00000000
Binary files a/elpa/ein-20200202.218/ein-pager.elc and /dev/null differ
diff --git a/elpa/ein-20200202.218/ein-pseudo-console.el b/elpa/ein-20200202.218/ein-pseudo-console.el
deleted file mode 100644
index 71d5d7e2..00000000
--- a/elpa/ein-20200202.218/ein-pseudo-console.el
+++ /dev/null
@@ -1,47 +0,0 @@
-;;; ein-pseudo-console.el --- Pseudo console mode
-
-;; Copyright (C) 2012 Takafumi Arakaki
-
-;; Author: Takafumi Arakaki <aka.tkf at gmail.com>
-
-;; This file is NOT part of GNU Emacs.
-
-;; ein-pseudo-console.el 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.
-
-;; ein-pseudo-console.el 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 ein-pseudo-console.el.
-;; If not, see <http://www.gnu.org/licenses/>.
-
-;;; Commentary:
-
-;;
-
-;;; Code:
-
-(defvar ein:pseudo-console-mode-map (make-sparse-keymap))
-
-(let ((map ein:pseudo-console-mode-map))
-  (define-key map "\C-m" 'ein:worksheet-execute-cell-and-insert-below))
-
-;;;###autoload
-(define-minor-mode ein:pseudo-console-mode
-  "Pseudo console mode.  Hit RET to execute code."
-  :lighter " ein:pseudo"
-  :keymap ein:pseudo-console-mode-map
-  :group 'ein)
-
-;; To avoid MuMaMo to discard `ein:pseudo-console-mode', make it
-;; permanent local.
-(put 'ein:pseudo-console-mode 'permanent-local t)
-
-(provide 'ein-pseudo-console)
-
-;;; ein-pseudo-console.el ends here
diff --git a/elpa/ein-20200202.218/ein-pseudo-console.elc b/elpa/ein-20200202.218/ein-pseudo-console.elc
deleted file mode 100644
index 4e03fde0..00000000
Binary files a/elpa/ein-20200202.218/ein-pseudo-console.elc and /dev/null differ
diff --git a/elpa/ein-20200202.218/ein-autoloads.el b/elpa/ein-20200205.1547/ein-autoloads.el
similarity index 91%
rename from elpa/ein-20200202.218/ein-autoloads.el
rename to elpa/ein-20200205.1547/ein-autoloads.el
index 5bee4014..10a27a37 100644
--- a/elpa/ein-20200202.218/ein-autoloads.el
+++ b/elpa/ein-20200205.1547/ein-autoloads.el
@@ -76,33 +76,6 @@ Open a buffer with bug report template.
 
 (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "ein-file" '("ein:" "*ein:file-buffername-template*")))
 
-;;;***
-
-;;;### (autoloads nil "ein-helm" "ein-helm.el" (0 0 0 0))
-;;; Generated autoloads from ein-helm.el
-
-(autoload 'anything-ein-kernel-history "ein-helm" "\
-Search kernel execution history then insert the selected one.
-
-\(fn)" t nil)
-
-(autoload 'helm-ein-kernel-history "ein-helm" "\
-Search kernel execution history then insert the selected one.
-
-\(fn)" t nil)
-
-(autoload 'anything-ein-notebook-buffers "ein-helm" "\
-Choose opened notebook using anything.el interface.
-
-\(fn)" t nil)
-
-(autoload 'helm-ein-notebook-buffers "ein-helm" "\
-Choose opened notebook using helm interface.
-
-\(fn)" t nil)
-
-(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "ein-helm" '("ein:helm-")))
-
 ;;;***
 
 ;;;### (autoloads nil "ein-iexec" "ein-iexec.el" (0 0 0 0))
@@ -352,13 +325,6 @@ and the url-or-port argument of ein:notebooklist-open*.
 
 (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "ein-output-area" '("ein:")))
 
-;;;***
-
-;;;### (autoloads nil "ein-pager" "ein-pager.el" (0 0 0 0))
-;;; Generated autoloads from ein-pager.el
-
-(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "ein-pager" '("ein:pager-")))
-
 ;;;***
 
 ;;;### (autoloads nil "ein-process" "ein-process.el" (0 0 0 0))
@@ -366,19 +332,6 @@ and the url-or-port argument of ein:notebooklist-open*.
 
 (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "ein-process" '("ein:")))
 
-;;;***
-
-;;;### (autoloads nil "ein-pseudo-console" "ein-pseudo-console.el"
-;;;;;;  (0 0 0 0))
-;;; Generated autoloads from ein-pseudo-console.el
-
-(autoload 'ein:pseudo-console-mode "ein-pseudo-console" "\
-Pseudo console mode.  Hit RET to execute code.
-
-\(fn &optional ARG)" t nil)
-
-(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "ein-pseudo-console" '("ein:pseudo-console-mode-map")))
-
 ;;;***
 
 ;;;### (autoloads nil "ein-pytools" "ein-pytools.el" (0 0 0 0))
diff --git a/elpa/ein-20200202.218/ein-cell.el b/elpa/ein-20200205.1547/ein-cell.el
similarity index 100%
rename from elpa/ein-20200202.218/ein-cell.el
rename to elpa/ein-20200205.1547/ein-cell.el
diff --git a/elpa/ein-20200202.218/ein-cell.elc b/elpa/ein-20200205.1547/ein-cell.elc
similarity index 100%
rename from elpa/ein-20200202.218/ein-cell.elc
rename to elpa/ein-20200205.1547/ein-cell.elc
diff --git a/elpa/ein-20200202.218/ein-classes.el b/elpa/ein-20200205.1547/ein-classes.el
similarity index 99%
rename from elpa/ein-20200202.218/ein-classes.el
rename to elpa/ein-20200205.1547/ein-classes.el
index 8b863bed..199cc720 100644
--- a/elpa/ein-20200202.218/ein-classes.el
+++ b/elpa/ein-20200205.1547/ein-classes.el
@@ -112,9 +112,6 @@
 `ein:$notebook-kernelinfo' : `ein:kernelinfo'
   `ein:kernelinfo' instance.
 
-`ein:$notebook-pager'
-  Variable for `ein:pager-*' functions. See ein-pager.el.
-
 `ein:$notebook-dirty' : boolean
   Set to `t' if notebook has unsaved changes.  Otherwise `nil'.
 
@@ -148,7 +145,6 @@
   kernel
   kernelinfo
   kernelspec
-  pager
   dirty
   metadata
   notebook-name
diff --git a/elpa/ein-20200202.218/ein-classes.elc b/elpa/ein-20200205.1547/ein-classes.elc
similarity index 85%
rename from elpa/ein-20200202.218/ein-classes.elc
rename to elpa/ein-20200205.1547/ein-classes.elc
index 9421b3ac..92fabeea 100644
Binary files a/elpa/ein-20200202.218/ein-classes.elc and b/elpa/ein-20200205.1547/ein-classes.elc differ
diff --git a/elpa/ein-20200202.218/ein-completer.el b/elpa/ein-20200205.1547/ein-completer.el
similarity index 100%
rename from elpa/ein-20200202.218/ein-completer.el
rename to elpa/ein-20200205.1547/ein-completer.el
diff --git a/elpa/ein-20200202.218/ein-completer.elc b/elpa/ein-20200205.1547/ein-completer.elc
similarity index 100%
rename from elpa/ein-20200202.218/ein-completer.elc
rename to elpa/ein-20200205.1547/ein-completer.elc
diff --git a/elpa/ein-20200202.218/ein-contents-api.el b/elpa/ein-20200205.1547/ein-contents-api.el
similarity index 98%
rename from elpa/ein-20200202.218/ein-contents-api.el
rename to elpa/ein-20200205.1547/ein-contents-api.el
index 909e7828..c2be5915 100644
--- a/elpa/ein-20200202.218/ein-contents-api.el
+++ b/elpa/ein-20200205.1547/ein-contents-api.el
@@ -106,10 +106,6 @@ ERRBACK of arity 1 for the contents."
                (ein:log 'error notice)
                (when errback (funcall errback url-or-port status-code)))))))))
 
-
-;; TODO: This is one place to check for redirects - update the url slot if so.
-;; Will need to pass the response object and check either request-response-history
-;; or request-response-url.
 (cl-defun ein:content-query-contents--success (url-or-port path callback
                                                &key data symbol-status response
                                                &allow-other-keys)
@@ -117,8 +113,6 @@ ERRBACK of arity 1 for the contents."
     (if (< (ein:notebook-version-numeric url-or-port) 3)
         (setq content (ein:new-content-legacy url-or-port path data))
       (setq content (ein:new-content url-or-port path data)))
-    (aif response
-        (setf (ein:$content-url-or-port content) (ein:get-response-redirect it)))
     (when callback
       (funcall callback content))))
 
diff --git a/elpa/ein-20200202.218/ein-contents-api.elc b/elpa/ein-20200205.1547/ein-contents-api.elc
similarity index 94%
rename from elpa/ein-20200202.218/ein-contents-api.elc
rename to elpa/ein-20200205.1547/ein-contents-api.elc
index d3867018..ff27888c 100644
Binary files a/elpa/ein-20200202.218/ein-contents-api.elc and b/elpa/ein-20200205.1547/ein-contents-api.elc differ
diff --git a/elpa/ein-20200202.218/ein-core.el b/elpa/ein-20200205.1547/ein-core.el
similarity index 100%
rename from elpa/ein-20200202.218/ein-core.el
rename to elpa/ein-20200205.1547/ein-core.el
diff --git a/elpa/ein-20200202.218/ein-core.elc b/elpa/ein-20200205.1547/ein-core.elc
similarity index 100%
rename from elpa/ein-20200202.218/ein-core.elc
rename to elpa/ein-20200205.1547/ein-core.elc
diff --git a/elpa/ein-20200202.218/ein-dev.el b/elpa/ein-20200205.1547/ein-dev.el
similarity index 100%
rename from elpa/ein-20200202.218/ein-dev.el
rename to elpa/ein-20200205.1547/ein-dev.el
diff --git a/elpa/ein-20200202.218/ein-dev.elc b/elpa/ein-20200205.1547/ein-dev.elc
similarity index 98%
rename from elpa/ein-20200202.218/ein-dev.elc
rename to elpa/ein-20200205.1547/ein-dev.elc
index d09d706f..9e23a7db 100644
Binary files a/elpa/ein-20200202.218/ein-dev.elc and b/elpa/ein-20200205.1547/ein-dev.elc differ
diff --git a/elpa/ein-20200202.218/ein-events.el b/elpa/ein-20200205.1547/ein-events.el
similarity index 100%
rename from elpa/ein-20200202.218/ein-events.el
rename to elpa/ein-20200205.1547/ein-events.el
diff --git a/elpa/ein-20200202.218/ein-events.elc b/elpa/ein-20200205.1547/ein-events.elc
similarity index 100%
rename from elpa/ein-20200202.218/ein-events.elc
rename to elpa/ein-20200205.1547/ein-events.elc
diff --git a/elpa/ein-20200202.218/ein-file.el b/elpa/ein-20200205.1547/ein-file.el
similarity index 100%
rename from elpa/ein-20200202.218/ein-file.el
rename to elpa/ein-20200205.1547/ein-file.el
diff --git a/elpa/ein-20200202.218/ein-file.elc b/elpa/ein-20200205.1547/ein-file.elc
similarity index 100%
rename from elpa/ein-20200202.218/ein-file.elc
rename to elpa/ein-20200205.1547/ein-file.elc
diff --git a/elpa/ein-20200202.218/ein-iexec.el b/elpa/ein-20200205.1547/ein-iexec.el
similarity index 100%
rename from elpa/ein-20200202.218/ein-iexec.el
rename to elpa/ein-20200205.1547/ein-iexec.el
diff --git a/elpa/ein-20200202.218/ein-iexec.elc b/elpa/ein-20200205.1547/ein-iexec.elc
similarity index 100%
rename from elpa/ein-20200202.218/ein-iexec.elc
rename to elpa/ein-20200205.1547/ein-iexec.elc
diff --git a/elpa/ein-20200202.218/ein-ipdb.el b/elpa/ein-20200205.1547/ein-ipdb.el
similarity index 100%
rename from elpa/ein-20200202.218/ein-ipdb.el
rename to elpa/ein-20200205.1547/ein-ipdb.el
diff --git a/elpa/ein-20200202.218/ein-ipdb.elc b/elpa/ein-20200205.1547/ein-ipdb.elc
similarity index 100%
rename from elpa/ein-20200202.218/ein-ipdb.elc
rename to elpa/ein-20200205.1547/ein-ipdb.elc
diff --git a/elpa/ein-20200202.218/ein-ipynb-mode.el b/elpa/ein-20200205.1547/ein-ipynb-mode.el
similarity index 100%
rename from elpa/ein-20200202.218/ein-ipynb-mode.el
rename to elpa/ein-20200205.1547/ein-ipynb-mode.el
diff --git a/elpa/ein-20200202.218/ein-ipynb-mode.elc b/elpa/ein-20200205.1547/ein-ipynb-mode.elc
similarity index 100%
rename from elpa/ein-20200202.218/ein-ipynb-mode.elc
rename to elpa/ein-20200205.1547/ein-ipynb-mode.elc
diff --git a/elpa/ein-20200202.218/ein-jupyter.el b/elpa/ein-20200205.1547/ein-jupyter.el
similarity index 100%
rename from elpa/ein-20200202.218/ein-jupyter.el
rename to elpa/ein-20200205.1547/ein-jupyter.el
diff --git a/elpa/ein-20200202.218/ein-jupyter.elc b/elpa/ein-20200205.1547/ein-jupyter.elc
similarity index 100%
rename from elpa/ein-20200202.218/ein-jupyter.elc
rename to elpa/ein-20200205.1547/ein-jupyter.elc
diff --git a/elpa/ein-20200202.218/ein-jupyterhub.el b/elpa/ein-20200205.1547/ein-jupyterhub.el
similarity index 100%
rename from elpa/ein-20200202.218/ein-jupyterhub.el
rename to elpa/ein-20200205.1547/ein-jupyterhub.el
diff --git a/elpa/ein-20200202.218/ein-jupyterhub.elc b/elpa/ein-20200205.1547/ein-jupyterhub.elc
similarity index 100%
rename from elpa/ein-20200202.218/ein-jupyterhub.elc
rename to elpa/ein-20200205.1547/ein-jupyterhub.elc
diff --git a/elpa/ein-20200202.218/ein-k8s.el b/elpa/ein-20200205.1547/ein-k8s.el
similarity index 100%
rename from elpa/ein-20200202.218/ein-k8s.el
rename to elpa/ein-20200205.1547/ein-k8s.el
diff --git a/elpa/ein-20200202.218/ein-k8s.elc b/elpa/ein-20200205.1547/ein-k8s.elc
similarity index 100%
rename from elpa/ein-20200202.218/ein-k8s.elc
rename to elpa/ein-20200205.1547/ein-k8s.elc
diff --git a/elpa/ein-20200202.218/ein-kernel.el b/elpa/ein-20200205.1547/ein-kernel.el
similarity index 100%
rename from elpa/ein-20200202.218/ein-kernel.el
rename to elpa/ein-20200205.1547/ein-kernel.el
diff --git a/elpa/ein-20200202.218/ein-kernel.elc b/elpa/ein-20200205.1547/ein-kernel.elc
similarity index 100%
rename from elpa/ein-20200202.218/ein-kernel.elc
rename to elpa/ein-20200205.1547/ein-kernel.elc
diff --git a/elpa/ein-20200202.218/ein-kernelinfo.el b/elpa/ein-20200205.1547/ein-kernelinfo.el
similarity index 100%
rename from elpa/ein-20200202.218/ein-kernelinfo.el
rename to elpa/ein-20200205.1547/ein-kernelinfo.el
diff --git a/elpa/ein-20200202.218/ein-kernelinfo.elc b/elpa/ein-20200205.1547/ein-kernelinfo.elc
similarity index 100%
rename from elpa/ein-20200202.218/ein-kernelinfo.elc
rename to elpa/ein-20200205.1547/ein-kernelinfo.elc
diff --git a/elpa/ein-20200202.218/ein-kill-ring.el b/elpa/ein-20200205.1547/ein-kill-ring.el
similarity index 100%
rename from elpa/ein-20200202.218/ein-kill-ring.el
rename to elpa/ein-20200205.1547/ein-kill-ring.el
diff --git a/elpa/ein-20200202.218/ein-kill-ring.elc b/elpa/ein-20200205.1547/ein-kill-ring.elc
similarity index 100%
rename from elpa/ein-20200202.218/ein-kill-ring.elc
rename to elpa/ein-20200205.1547/ein-kill-ring.elc
diff --git a/elpa/ein-20200202.218/ein-log.el b/elpa/ein-20200205.1547/ein-log.el
similarity index 100%
rename from elpa/ein-20200202.218/ein-log.el
rename to elpa/ein-20200205.1547/ein-log.el
diff --git a/elpa/ein-20200202.218/ein-log.elc b/elpa/ein-20200205.1547/ein-log.elc
similarity index 100%
rename from elpa/ein-20200202.218/ein-log.elc
rename to elpa/ein-20200205.1547/ein-log.elc
diff --git a/elpa/ein-20200202.218/ein-markdown-mode.el b/elpa/ein-20200205.1547/ein-markdown-mode.el
similarity index 100%
rename from elpa/ein-20200202.218/ein-markdown-mode.el
rename to elpa/ein-20200205.1547/ein-markdown-mode.el
diff --git a/elpa/ein-20200202.218/ein-markdown-mode.elc b/elpa/ein-20200205.1547/ein-markdown-mode.elc
similarity index 100%
rename from elpa/ein-20200202.218/ein-markdown-mode.elc
rename to elpa/ein-20200205.1547/ein-markdown-mode.elc
diff --git a/elpa/ein-20200202.218/ein-node.el b/elpa/ein-20200205.1547/ein-node.el
similarity index 100%
rename from elpa/ein-20200202.218/ein-node.el
rename to elpa/ein-20200205.1547/ein-node.el
diff --git a/elpa/ein-20200202.218/ein-node.elc b/elpa/ein-20200205.1547/ein-node.elc
similarity index 100%
rename from elpa/ein-20200202.218/ein-node.elc
rename to elpa/ein-20200205.1547/ein-node.elc
diff --git a/elpa/ein-20200202.218/ein-notebook.el b/elpa/ein-20200205.1547/ein-notebook.el
similarity index 99%
rename from elpa/ein-20200202.218/ein-notebook.el
rename to elpa/ein-20200205.1547/ein-notebook.el
index 38974882..dd8f4961 100644
--- a/elpa/ein-20200202.218/ein-notebook.el
+++ b/elpa/ein-20200205.1547/ein-notebook.el
@@ -49,8 +49,6 @@
 (require 'ein-scratchsheet)
 (require 'ein-notification)
 (require 'ein-completer)
-(require 'ein-pager)
-(require 'ein-pseudo-console)
 (require 'ein-events)
 (require 'ein-notification)
 (require 'ein-kill-ring)
@@ -133,8 +131,6 @@ Current buffer for these functions is set to the notebook buffer.")
 ;; is at:
 ;; https://github.com/ipython/ipython/wiki/IPEP-16%3A-Notebook-multi-directory-dashboard-and-URL-mapping
 
-
-(defvar ein:notebook-pager-buffer-name-template "*ein:pager %s/%s*")
 (defvar ein:notebook-buffer-name-template "*ein: %s/%s*")
 
 (ein:deflocal ein:%notebook% nil
@@ -386,14 +382,7 @@ of minor mode."
 (defun ein:notebook-bind-events (notebook events)
   "Bind events related to PAGER to the event handler EVENTS."
   (setf (ein:$notebook-events notebook) events)
-  (ein:worksheet-class-bind-events events)
-  ;; Bind events for sub components:
-  (setf (ein:$notebook-pager notebook)
-        (ein:pager-new
-         (format ein:notebook-pager-buffer-name-template
-                 (ein:$notebook-url-or-port notebook)
-                 (ein:$notebook-notebook-name notebook))
-         (ein:$notebook-events notebook))))
+  (ein:worksheet-class-bind-events events))
 
 (defalias 'ein:notebook-reconnect-kernel 'ein:notebook-reconnect-session-command "The distinction between kernel and session is a bit mysterious, all the action is now occurring in `ein:notebook-reconnect-session-command' these days, for which this function is now an alias.")
 
@@ -1276,8 +1265,12 @@ Tried add-function: the &rest from :around is an emacs-25 compilation issue."
             ("Execute cell and insert below"
              ein:worksheet-execute-cell-and-insert-below
              :active (ein:worksheet-at-codecell-p))
-            ("Execute all"
-             ein:worksheet-execute-all-cell)
+            ("Execute all cells"
+             ein:worksheet-execute-all-cells)
+	    ("Execute all cells above"
+             ein:worksheet-execute-all-cells-above)
+	    ("Execute all cells below"
+             ein:worksheet-execute-all-cells-below)
             ))
        "---"
        ,@(ein:generate-menu
diff --git a/elpa/ein-20200202.218/ein-notebook.elc b/elpa/ein-20200205.1547/ein-notebook.elc
similarity index 93%
rename from elpa/ein-20200202.218/ein-notebook.elc
rename to elpa/ein-20200205.1547/ein-notebook.elc
index ab2e2039..db870ff1 100644
Binary files a/elpa/ein-20200202.218/ein-notebook.elc and b/elpa/ein-20200205.1547/ein-notebook.elc differ
diff --git a/elpa/ein-20200202.218/ein-notebooklist.el b/elpa/ein-20200205.1547/ein-notebooklist.el
similarity index 99%
rename from elpa/ein-20200202.218/ein-notebooklist.el
rename to elpa/ein-20200205.1547/ein-notebooklist.el
index 548e0174..8494db7e 100644
--- a/elpa/ein-20200202.218/ein-notebooklist.el
+++ b/elpa/ein-20200205.1547/ein-notebooklist.el
@@ -228,7 +228,8 @@ See `ein:format-time-string'."
            (ein:url url-or-port (ein:$content-path content)))
   (with-current-buffer (ein:notebooklist-get-buffer url-or-port)
     (let ((restore-point (ein:aand (widget-at)
-                                   (widget-value it)
+                                   (aif (widget-value it)
+                                       (and (stringp it) it))
                                    (string-match-p "Open\\|Stop\\|Delete" it)
                                    (point))))
       (aif ein:%notebooklist%
diff --git a/elpa/ein-20200202.218/ein-notebooklist.elc b/elpa/ein-20200205.1547/ein-notebooklist.elc
similarity index 94%
rename from elpa/ein-20200202.218/ein-notebooklist.elc
rename to elpa/ein-20200205.1547/ein-notebooklist.elc
index 459508b1..59a20f62 100644
Binary files a/elpa/ein-20200202.218/ein-notebooklist.elc and b/elpa/ein-20200205.1547/ein-notebooklist.elc differ
diff --git a/elpa/ein-20200202.218/ein-notification.el b/elpa/ein-20200205.1547/ein-notification.el
similarity index 100%
rename from elpa/ein-20200202.218/ein-notification.el
rename to elpa/ein-20200205.1547/ein-notification.el
diff --git a/elpa/ein-20200202.218/ein-notification.elc b/elpa/ein-20200205.1547/ein-notification.elc
similarity index 100%
rename from elpa/ein-20200202.218/ein-notification.elc
rename to elpa/ein-20200205.1547/ein-notification.elc
diff --git a/elpa/ein-20200202.218/ein-output-area.el b/elpa/ein-20200205.1547/ein-output-area.el
similarity index 100%
rename from elpa/ein-20200202.218/ein-output-area.el
rename to elpa/ein-20200205.1547/ein-output-area.el
diff --git a/elpa/ein-20200202.218/ein-output-area.elc b/elpa/ein-20200205.1547/ein-output-area.elc
similarity index 100%
rename from elpa/ein-20200202.218/ein-output-area.elc
rename to elpa/ein-20200205.1547/ein-output-area.elc
diff --git a/elpa/ein-20200202.218/ein-pkg.el b/elpa/ein-20200205.1547/ein-pkg.el
similarity index 81%
rename from elpa/ein-20200202.218/ein-pkg.el
rename to elpa/ein-20200205.1547/ein-pkg.el
index ab790c7a..eee630d2 100644
--- a/elpa/ein-20200202.218/ein-pkg.el
+++ b/elpa/ein-20200205.1547/ein-pkg.el
@@ -1,4 +1,4 @@
-(define-package "ein" "20200202.218" "Emacs IPython Notebook"
+(define-package "ein" "20200205.1547" "Emacs IPython Notebook"
   '((emacs "25")
     (websocket "20190620.338")
     (anaphora "20180618")
diff --git a/elpa/ein-20200202.218/ein-process.el b/elpa/ein-20200205.1547/ein-process.el
similarity index 100%
rename from elpa/ein-20200202.218/ein-process.el
rename to elpa/ein-20200205.1547/ein-process.el
diff --git a/elpa/ein-20200202.218/ein-process.elc b/elpa/ein-20200205.1547/ein-process.elc
similarity index 100%
rename from elpa/ein-20200202.218/ein-process.elc
rename to elpa/ein-20200205.1547/ein-process.elc
diff --git a/elpa/ein-20200202.218/ein-pytools.el b/elpa/ein-20200205.1547/ein-pytools.el
similarity index 100%
rename from elpa/ein-20200202.218/ein-pytools.el
rename to elpa/ein-20200205.1547/ein-pytools.el
diff --git a/elpa/ein-20200202.218/ein-pytools.elc b/elpa/ein-20200205.1547/ein-pytools.elc
similarity index 100%
rename from elpa/ein-20200202.218/ein-pytools.elc
rename to elpa/ein-20200205.1547/ein-pytools.elc
diff --git a/elpa/ein-20200202.218/ein-query.el b/elpa/ein-20200205.1547/ein-query.el
similarity index 92%
rename from elpa/ein-20200202.218/ein-query.el
rename to elpa/ein-20200205.1547/ein-query.el
index 5c22c1b7..4f3894d2 100644
--- a/elpa/ein-20200202.218/ein-query.el
+++ b/elpa/ein-20200205.1547/ein-query.el
@@ -122,15 +122,6 @@ aborts).  Instead you will see Race! in debug messages.
   (setq settings (plist-put settings :sync ein:force-sync))
   (apply #'request (url-encode-url url) (ein:query-prepare-header url settings)))
 
-(defun ein:get-response-redirect (response)
-  "Determine if the query has been redirected, and if so return then URL the request was redirected to."
-  (if (length (request-response-history response))
-      (let ((url (url-generic-parse-url (format "%s" (request-response-url response)))))
-        (format "%s://%s:%s"
-                (url-type url)
-                (url-host url)
-                (url-port url)))))
-
 ;;; Cookie
 
 (defalias 'ein:query-get-cookie 'request-cookie-string)
diff --git a/elpa/ein-20200202.218/ein-query.elc b/elpa/ein-20200205.1547/ein-query.elc
similarity index 87%
rename from elpa/ein-20200202.218/ein-query.elc
rename to elpa/ein-20200205.1547/ein-query.elc
index c1d072f7..e702d83f 100644
Binary files a/elpa/ein-20200202.218/ein-query.elc and b/elpa/ein-20200205.1547/ein-query.elc differ
diff --git a/elpa/ein-20200202.218/ein-scratchsheet.el b/elpa/ein-20200205.1547/ein-scratchsheet.el
similarity index 100%
rename from elpa/ein-20200202.218/ein-scratchsheet.el
rename to elpa/ein-20200205.1547/ein-scratchsheet.el
diff --git a/elpa/ein-20200202.218/ein-scratchsheet.elc b/elpa/ein-20200205.1547/ein-scratchsheet.elc
similarity index 100%
rename from elpa/ein-20200202.218/ein-scratchsheet.elc
rename to elpa/ein-20200205.1547/ein-scratchsheet.elc
diff --git a/elpa/ein-20200202.218/ein-shared-output.el b/elpa/ein-20200205.1547/ein-shared-output.el
similarity index 100%
rename from elpa/ein-20200202.218/ein-shared-output.el
rename to elpa/ein-20200205.1547/ein-shared-output.el
diff --git a/elpa/ein-20200202.218/ein-shared-output.elc b/elpa/ein-20200205.1547/ein-shared-output.elc
similarity index 100%
rename from elpa/ein-20200202.218/ein-shared-output.elc
rename to elpa/ein-20200205.1547/ein-shared-output.elc
diff --git a/elpa/ein-20200202.218/ein-traceback.el b/elpa/ein-20200205.1547/ein-traceback.el
similarity index 100%
rename from elpa/ein-20200202.218/ein-traceback.el
rename to elpa/ein-20200205.1547/ein-traceback.el
diff --git a/elpa/ein-20200202.218/ein-traceback.elc b/elpa/ein-20200205.1547/ein-traceback.elc
similarity index 99%
rename from elpa/ein-20200202.218/ein-traceback.elc
rename to elpa/ein-20200205.1547/ein-traceback.elc
index c418f645..1b227db2 100644
Binary files a/elpa/ein-20200202.218/ein-traceback.elc and b/elpa/ein-20200205.1547/ein-traceback.elc differ
diff --git a/elpa/ein-20200202.218/ein-utils.el b/elpa/ein-20200205.1547/ein-utils.el
similarity index 100%
rename from elpa/ein-20200202.218/ein-utils.el
rename to elpa/ein-20200205.1547/ein-utils.el
diff --git a/elpa/ein-20200202.218/ein-utils.elc b/elpa/ein-20200205.1547/ein-utils.elc
similarity index 100%
rename from elpa/ein-20200202.218/ein-utils.elc
rename to elpa/ein-20200205.1547/ein-utils.elc
diff --git a/elpa/ein-20200202.218/ein-websocket.el b/elpa/ein-20200205.1547/ein-websocket.el
similarity index 100%
rename from elpa/ein-20200202.218/ein-websocket.el
rename to elpa/ein-20200205.1547/ein-websocket.el
diff --git a/elpa/ein-20200202.218/ein-websocket.elc b/elpa/ein-20200205.1547/ein-websocket.elc
similarity index 100%
rename from elpa/ein-20200202.218/ein-websocket.elc
rename to elpa/ein-20200205.1547/ein-websocket.elc
diff --git a/elpa/ein-20200202.218/ein-worksheet.el b/elpa/ein-20200205.1547/ein-worksheet.el
similarity index 96%
rename from elpa/ein-20200202.218/ein-worksheet.el
rename to elpa/ein-20200205.1547/ein-worksheet.el
index 4c653476..c07269fd 100644
--- a/elpa/ein-20200202.218/ein-worksheet.el
+++ b/elpa/ein-20200205.1547/ein-worksheet.el
@@ -1053,11 +1053,41 @@ cell bellow."
                      (ein:worksheet-get-current-cell)))
   (ein:worksheet-execute-cell-and-goto-next ws cell t))
 
-(defun ein:worksheet-execute-all-cell (ws)
-  "Execute all cells in the current worksheet buffer."
+(define-obsolete-function-alias
+  'ein:worksheet-execute-all-cell 'ein:worksheet-execute-all-cells "0.17.0")
+
+(cl-defun ein:worksheet-execute-all-cells (ws &key above below)
+  "Execute all cells in the current worksheet buffer.
+If :above or :below specified, execute above/below the current cell."
   (interactive (list (ein:worksheet--get-ws-or-error)))
-  (mapc #'ein:cell-execute
-        (seq-filter #'ein:codecell-p (ein:worksheet-get-cells ws))))
+  (let* ((all (seq-filter #'ein:codecell-p (ein:worksheet-get-cells ws)))
+         (current-id (aif (ein:worksheet-get-current-cell) (slot-value it 'cell-id)))
+         (not-matching (apply-partially (lambda (my other)
+                                          (not (string= (slot-value other 'cell-id) my)))
+                                        current-id)))
+    (mapc #'ein:cell-execute
+          (if (or above below)
+              (append (when (and current-id above)
+                        (aif (seq-take-while not-matching all)
+                            it
+                          (prog1 nil
+                            (ein:log 'info
+                              "ein:worksheet-execute-all-cells: no cells above current"))))
+                      (when (and current-id below)
+                        (seq-drop-while not-matching all)))
+            all))))
+
+(defun ein:worksheet-execute-all-cells-above (ws)
+  "Execute all cells above the current cell (exclusively) in the
+current worksheet buffer."
+  (interactive (list (ein:worksheet--get-ws-or-error)))
+  (ein:worksheet-execute-all-cells ws :above t))
+
+(defun ein:worksheet-execute-all-cells-below (ws)
+  "Execute all cells below the current cell (inclusively) in the
+current worksheet buffer."
+  (interactive (list (ein:worksheet--get-ws-or-error)))
+  (ein:worksheet-execute-all-cells ws :below t))
 
 ;;; Metadata
 
@@ -1114,40 +1144,6 @@ cell bellow."
     (indent-rigidly
      beg end (- (ein:find-leftmost-column beg end)))))
 
-(defun ein:worksheet--cells-before-cell (ws cell)
-  (let ((cells (ein:worksheet-get-cells ws)))
-    (cl-loop for c in cells
-          collecting c
-          until (eql (ein:cell-id c) (ein:cell-id cell)))))
-
-(defun ein:worksheet--cells-after-cell (ws cell)
-  (let ((cells (ein:worksheet-get-cells ws))
-        (prior-cells (length (ein:worksheet--cells-before-cell ws cell))))
-    (seq-drop cells prior-cells)))
-
-(defun ein:worksheet-first-executing-cell (cells)
-  (cl-loop for c in cells
-        when (and (ein:codecell-p c)
-                  (slot-value c 'running))
-        return c))
-
-(defun ein:worksheet-jump-to-first-executing-cell ()
-  "Move the point to the first executing cell in the current worksheet."
-  (interactive)
-  (aif (ein:worksheet-first-executing-cell (ein:worksheet-get-cells ein:%worksheet%))
-      (ein:cell-goto it)
-    (message "No cell currently executing.")))
-
-(defun ein:worksheet-jump-to-next-executing-cell ()
-  "Move the point to the next executing cell in the current worksheet."
-  (interactive)
-  (let* ((curcell (ein:get-cell-at-point--worksheet))
-         (restcells (ein:worksheet--cells-after-cell ein:%worksheet% curcell)))
-    (aif (ein:worksheet-first-executing-cell restcells)
-        (ein:cell-goto it)
-      (message "No additional cells are executing."))))
-
-
 ;;; Auto-execution
 
 (defun ein:worksheet-toggle-autoexec (cell)
diff --git a/elpa/ein-20200202.218/ein-worksheet.elc b/elpa/ein-20200205.1547/ein-worksheet.elc
similarity index 95%
rename from elpa/ein-20200202.218/ein-worksheet.elc
rename to elpa/ein-20200205.1547/ein-worksheet.elc
index f56aca1b..474309f0 100644
Binary files a/elpa/ein-20200202.218/ein-worksheet.elc and b/elpa/ein-20200205.1547/ein-worksheet.elc differ
diff --git a/elpa/ein-20200202.218/ein.el b/elpa/ein-20200205.1547/ein.el
similarity index 100%
rename from elpa/ein-20200202.218/ein.el
rename to elpa/ein-20200205.1547/ein.el
diff --git a/elpa/ein-20200202.218/ein.elc b/elpa/ein-20200205.1547/ein.elc
similarity index 100%
rename from elpa/ein-20200202.218/ein.elc
rename to elpa/ein-20200205.1547/ein.elc
diff --git a/elpa/ein-20200202.218/ob-ein.el b/elpa/ein-20200205.1547/ob-ein.el
similarity index 100%
rename from elpa/ein-20200202.218/ob-ein.el
rename to elpa/ein-20200205.1547/ob-ein.el
diff --git a/elpa/ein-20200202.218/ob-ein.elc b/elpa/ein-20200205.1547/ob-ein.elc
similarity index 92%
rename from elpa/ein-20200202.218/ob-ein.elc
rename to elpa/ein-20200205.1547/ob-ein.elc
index a91a8989..3f0df0ee 100644
Binary files a/elpa/ein-20200202.218/ob-ein.elc and b/elpa/ein-20200205.1547/ob-ein.elc differ
diff --git a/elpa/ein-20200202.218/poly-ein.el b/elpa/ein-20200205.1547/poly-ein.el
similarity index 100%
rename from elpa/ein-20200202.218/poly-ein.el
rename to elpa/ein-20200205.1547/poly-ein.el
diff --git a/elpa/ein-20200202.218/poly-ein.elc b/elpa/ein-20200205.1547/poly-ein.elc
similarity index 100%
rename from elpa/ein-20200202.218/poly-ein.elc
rename to elpa/ein-20200205.1547/poly-ein.elc
diff --git a/elpa/flucui-themes-20190321.2313/flucui-dark-theme.el b/elpa/flucui-themes-20200204.1930/flucui-dark-theme.el
similarity index 97%
rename from elpa/flucui-themes-20190321.2313/flucui-dark-theme.el
rename to elpa/flucui-themes-20200204.1930/flucui-dark-theme.el
index 7eb5f094..72572b5b 100644
--- a/elpa/flucui-themes-20190321.2313/flucui-dark-theme.el
+++ b/elpa/flucui-themes-20200204.1930/flucui-dark-theme.el
@@ -96,6 +96,7 @@
                               :foreground ,fui-bg))))
    `(highlight ((t (:inverse-video nil :background ,fui-asphalt))))
    `(hl-line ((t (:inverse-video nil :background ,fui-asphalt))))
+   `(widget-field ((t (:background ,fui-dark-concrete))))
 
    ;; Face for specific prog modes
    `(sh-heredoc ((t (:foreground nil :inherit font-lock-string-face))))
@@ -277,6 +278,11 @@
    ;; Highlight-indent-guides
    `(highlight-indent-guides-odd-face ((t (:background ,fui-deep-asphalt))))
    `(highlight-indent-guides-even-face ((t (:background nil))))
+
+   ;; Telega
+   `(telega-msg-heading ((t (:background nil :foreground ,fui-emerald :inherit nil))))
+   `(telega-msg-inline-reply ((t (:foreground ,fui-dark-concrete :inherit nil))))
+   `(telega-entity-type-texturl ((t (:inherit nil :foreground ,fui-river))))
    ))
 
 (provide-theme 'flucui-dark)
diff --git a/elpa/flucui-themes-20190321.2313/flucui-light-theme.el b/elpa/flucui-themes-20200204.1930/flucui-light-theme.el
similarity index 97%
rename from elpa/flucui-themes-20190321.2313/flucui-light-theme.el
rename to elpa/flucui-themes-20200204.1930/flucui-light-theme.el
index 3fc64cbf..f30e93df 100644
--- a/elpa/flucui-themes-20190321.2313/flucui-light-theme.el
+++ b/elpa/flucui-themes-20200204.1930/flucui-light-theme.el
@@ -96,6 +96,7 @@
                               :foreground ,fui-clouds))))
    `(highlight ((t (:inverse-video nil :background ,fui-deep-clouds))))
    `(hl-line ((t (:inverse-video nil :background ,fui-deep-clouds))))
+   `(widget-field ((t (:background ,fui-concrete))))
 
    ;; Face for specific prog modes
    `(sh-heredoc ((t (:foreground nil :inherit font-lock-string-face))))
@@ -277,7 +278,12 @@
    ;; Highlight-indent-guides
    `(highlight-indent-guides-odd-face ((t (:background ,fui-deep-clouds))))
    `(highlight-indent-guides-even-face ((t (:background nil))))
-   ))
+
+   ;; Telega
+   `(telega-msg-heading ((t (:background nil :foreground ,fui-dark-emerald :inherit nil))))
+   `(telega-msg-inline-reply ((t (:foreground ,fui-concrete :inherit nil))))
+   `(telega-entity-type-texturl ((t (:inherit nil :foreground ,fui-dark-river))))
+  ))
 
 (provide-theme 'flucui-light)
 
diff --git a/elpa/flucui-themes-20190321.2313/flucui-themes-autoloads.el b/elpa/flucui-themes-20200204.1930/flucui-themes-autoloads.el
similarity index 100%
rename from elpa/flucui-themes-20190321.2313/flucui-themes-autoloads.el
rename to elpa/flucui-themes-20200204.1930/flucui-themes-autoloads.el
diff --git a/elpa/flucui-themes-20190321.2313/flucui-themes-pkg.el b/elpa/flucui-themes-20200204.1930/flucui-themes-pkg.el
similarity index 82%
rename from elpa/flucui-themes-20190321.2313/flucui-themes-pkg.el
rename to elpa/flucui-themes-20200204.1930/flucui-themes-pkg.el
index 47afdf74..271db39f 100644
--- a/elpa/flucui-themes-20190321.2313/flucui-themes-pkg.el
+++ b/elpa/flucui-themes-20200204.1930/flucui-themes-pkg.el
@@ -1,4 +1,4 @@
-(define-package "flucui-themes" "20190321.2313" "Custom theme inspired by the Flat UI palette"
+(define-package "flucui-themes" "20200204.1930" "Custom theme inspired by the Flat UI palette"
   '((emacs "24"))
   :keywords
   '("lisp")
diff --git a/elpa/flucui-themes-20190321.2313/flucui-themes.el b/elpa/flucui-themes-20200204.1930/flucui-themes.el
similarity index 100%
rename from elpa/flucui-themes-20190321.2313/flucui-themes.el
rename to elpa/flucui-themes-20200204.1930/flucui-themes.el
diff --git a/elpa/flucui-themes-20190321.2313/flucui-themes.elc b/elpa/flucui-themes-20200204.1930/flucui-themes.elc
similarity index 100%
rename from elpa/flucui-themes-20190321.2313/flucui-themes.elc
rename to elpa/flucui-themes-20200204.1930/flucui-themes.elc
diff --git a/elpa/git-commit-20200123.1706/git-commit-pkg.el b/elpa/git-commit-20200123.1706/git-commit-pkg.el
deleted file mode 100644
index adcb126c..00000000
--- a/elpa/git-commit-20200123.1706/git-commit-pkg.el
+++ /dev/null
@@ -1,2 +0,0 @@
-;;; -*- no-byte-compile: t -*-
-(define-package "git-commit" "20200123.1706" "Edit Git commit messages" '((emacs "25.1") (dash "20180910") (transient "20190812") (with-editor "20181103")) :commit "e5e475c61ce568a7e20ed8f795fa343a93632871" :keywords '("git" "tools" "vc") :maintainer '("Jonas Bernoulli" . "jonas@bernoul.li") :url "https://github.com/magit/magit")
diff --git a/elpa/git-commit-20200123.1706/git-commit-autoloads.el b/elpa/git-commit-20200204.2012/git-commit-autoloads.el
similarity index 100%
rename from elpa/git-commit-20200123.1706/git-commit-autoloads.el
rename to elpa/git-commit-20200204.2012/git-commit-autoloads.el
diff --git a/elpa/git-commit-20200204.2012/git-commit-pkg.el b/elpa/git-commit-20200204.2012/git-commit-pkg.el
new file mode 100644
index 00000000..c9876f8f
--- /dev/null
+++ b/elpa/git-commit-20200204.2012/git-commit-pkg.el
@@ -0,0 +1,2 @@
+;;; -*- no-byte-compile: t -*-
+(define-package "git-commit" "20200204.2012" "Edit Git commit messages" '((emacs "25.1") (dash "20180910") (transient "20190812") (with-editor "20181103")) :commit "bdd2b09e48541ac770b7d16f66d5997b971623f5" :keywords '("git" "tools" "vc") :maintainer '("Jonas Bernoulli" . "jonas@bernoul.li") :url "https://github.com/magit/magit")
diff --git a/elpa/git-commit-20200123.1706/git-commit.el b/elpa/git-commit-20200204.2012/git-commit.el
similarity index 99%
rename from elpa/git-commit-20200123.1706/git-commit.el
rename to elpa/git-commit-20200204.2012/git-commit.el
index 0a17bf84..093970ed 100644
--- a/elpa/git-commit-20200123.1706/git-commit.el
+++ b/elpa/git-commit-20200204.2012/git-commit.el
@@ -12,7 +12,7 @@
 ;; Maintainer: Jonas Bernoulli <jonas@bernoul.li>
 
 ;; Package-Requires: ((emacs "25.1") (dash "20180910") (transient "20190812") (with-editor "20181103"))
-;; Package-Version: 20200123.1706
+;; Package-Version: 20200204.2012
 ;; Keywords: git tools vc
 ;; Homepage: https://github.com/magit/magit
 
@@ -768,6 +768,8 @@ With a numeric prefix ARG, go forward ARG comments."
             (ignore-errors (car (process-lines "git" "config" "user.email")))
             (read-string "Email: "))))
 
+(defvar git-commit-read-ident-history nil)
+
 (defun git-commit-read-ident (prompt)
   (if (require 'magit-git nil t)
       (let ((str (magit-completing-read
diff --git a/elpa/git-commit-20200123.1706/git-commit.elc b/elpa/git-commit-20200204.2012/git-commit.elc
similarity index 99%
rename from elpa/git-commit-20200123.1706/git-commit.elc
rename to elpa/git-commit-20200204.2012/git-commit.elc
index 6bb4b1f5..c23869a2 100644
Binary files a/elpa/git-commit-20200123.1706/git-commit.elc and b/elpa/git-commit-20200204.2012/git-commit.elc differ
diff --git a/elpa/js2-mode-20190815.1327/js2-imenu-extras.el b/elpa/js2-mode-20190815.1327/js2-imenu-extras.el
deleted file mode 100644
index dfdedc8e..00000000
--- a/elpa/js2-mode-20190815.1327/js2-imenu-extras.el
+++ /dev/null
@@ -1,349 +0,0 @@
-;;; js2-imenu-extras.el --- Imenu support for additional constructs
-
-;; Copyright (C) 2012-2014  Free Software Foundation, Inc.
-
-;; Author:    Dmitry Gutov <dgutov@yandex.ru>
-;; Keywords:  languages, javascript, imenu
-
-;; This file is part of GNU Emacs.
-
-;; GNU Emacs is free software: you can redistribute it and/or modify
-;; it under the terms of the GNU General Public License as published by
-;; the Free Software Foundation, either version 3 of the License, or
-;; (at your option) any later version.
-
-;; GNU Emacs is distributed in the hope that it will be useful,
-;; but WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-;; GNU General Public License for more details.
-
-;; You should have received a copy of the GNU General Public License
-;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
-
-;;; Commentary:
-
-;; This package adds Imenu support for additional framework constructs and
-;; structural patterns to `js2-mode'.
-
-;; Usage:
-
-;; (add-hook 'js2-mode-hook 'js2-imenu-extras-mode)
-
-;; To customize how it works:
-;;   M-x customize-group RET js2-imenu RET
-
-(eval-when-compile
-  (require 'cl))
-
-(require 'js2-mode)
-
-(defvar js2-imenu-extension-styles
-  `((:framework jquery
-     :call-re   "\\_<\\(?:jQuery\\|\\$\\|_\\)\\.extend\\s-*("
-     :recorder  js2-imenu-record-jquery-extend)
-
-    (:framework jquery-ui
-     :call-re   "^\\s-*\\(?:jQuery\\|\\$\\)\\.widget\\s-*("
-     :recorder  js2-imenu-record-string-declare)
-
-    (:framework dojo
-     :call-re   "^\\s-*dojo.declare\\s-*("
-     :recorder  js2-imenu-record-string-declare)
-
-    (:framework backbone
-     :call-re   ,(concat "\\_<" js2-mode-identifier-re "\\.extend\\s-*(")
-     :recorder  js2-imenu-record-backbone-extend)
-
-    (:framework enyo
-     :call-re   "\\_<enyo\\.kind\\s-*("
-     :recorder  js2-imenu-record-enyo-kind)
-
-    (:framework react
-     :call-re "\\_<React\\.createClass\\s-*("
-     :recorder js2-imenu-record-react-class)
-
-    (:framework sencha
-     :call-re "^\\s-*Ext\\.define\\s-*("
-     :recorder js2-imenu-record-sencha-class))
-  "List of JavaScript class definition or extension styles.
-
-:framework is a valid value in `js2-imenu-enabled-frameworks'.
-
-:call-re is a regular expression that has no capturing groups.
-
-:recorder is a function name that will be called when the regular
-expression matches some text in the buffer.  When it's called, point will be
-at the end of the match.  The function must keep the point position.")
-
-(defconst js2-imenu-available-frameworks
-  (mapcar (lambda (style) (plist-get style :framework)) js2-imenu-extension-styles)
-  "List of available JavaScript framework symbols.")
-
-(defcustom js2-imenu-enabled-frameworks js2-imenu-available-frameworks
-  "Frameworks to be recognized by `js2-mode'."
-  :type (cons 'set (mapcar (lambda (x) (list 'const x))
-                           js2-imenu-available-frameworks))
-  :group 'js2-imenu)
-
-(defcustom js2-imenu-show-other-functions t
-  "Non-nil to show functions not recognized by other mechanisms,
-in a shared namespace."
-  :type 'boolean
-  :group 'js2-imenu)
-
-(defcustom js2-imenu-other-functions-ns "?"
-  "Namespace name to use for other functions."
-  :type 'string
-  :group 'js2-imenu)
-
-(defcustom js2-imenu-show-module-pattern t
-  "Non-nil to recognize the module pattern:
-
-var foobs = (function(a) {
-  return {fib: function() {}, fub: function() {}};
-})(b);
-
-We record the returned hash as belonging to the named module, and
-prefix any functions defined inside the IIFE with the module name."
-  :type 'boolean
-  :group 'js2-imenu)
-
-(defcustom js2-imenu-split-string-identifiers t
-  "When non-nil, split string identifiers on dots.
-Currently used for jQuery widgets, Dojo and Enyo declarations."
-  :type 'boolean
-  :group 'js2-imenu)
-
-;;;###autoload
-(defun js2-imenu-extras-setup ()
-  (when js2-imenu-enabled-frameworks
-    (add-hook 'js2-build-imenu-callbacks 'js2-imenu-record-declarations t t))
-  (when (or js2-imenu-show-other-functions js2-imenu-show-module-pattern)
-    (add-hook 'js2-build-imenu-callbacks 'js2-imenu-walk-ast t t)))
-
-(defun js2-imenu-extras-remove ()
-  (remove-hook 'js2-build-imenu-callbacks 'js2-imenu-record-declarations t)
-  (remove-hook 'js2-build-imenu-callbacks 'js2-imenu-walk-ast t))
-
-(defun js2-imenu-record-declarations ()
-  (let* ((styles (loop for style in js2-imenu-extension-styles
-                       when (memq (plist-get style :framework)
-                                  js2-imenu-enabled-frameworks)
-                       collect style))
-         (re (mapconcat (lambda (style)
-                          (concat "\\(" (plist-get style :call-re) "\\)"))
-                        styles "\\|")))
-    (goto-char (point-min))
-    (while (js2-re-search-forward re nil t)
-      (loop for i from 0 to (1- (length styles))
-            when (match-beginning (1+ i))
-            return (funcall (plist-get (nth i styles) :recorder))))))
-
-(defun js2-imenu-record-jquery-extend ()
-  (let ((pred (lambda (subject)
-                (and
-                 (js2-prop-get-node-p subject)
-                 (string= (js2-name-node-name (js2-prop-get-node-right subject))
-                          "prototype")))))
-    (js2-imenu-record-extend-first-arg (1- (point)) pred
-                                       'js2-compute-nested-prop-get)))
-
-(defun js2-imenu-record-string-declare ()
-  (js2-imenu-record-extend-first-arg
-   (1- (point)) 'js2-string-node-p
-   (lambda (node)
-     (if js2-imenu-split-string-identifiers
-         (split-string (js2-string-node-value node) "\\." t)
-       (list (js2-string-node-value node))))))
-
-(defun js2-imenu-record-extend-first-arg (point pred qname-fn)
-  (let* ((node (js2-node-at-point point))
-         (args (js2-call-node-args node))
-         (subject (first args)))
-    (when (funcall pred subject)
-      (loop for arg in (cdr args)
-            when (js2-object-node-p arg)
-            do (js2-record-object-literal
-                arg (funcall qname-fn subject) (js2-node-abs-pos arg))))))
-
-(defun js2-imenu-record-backbone-or-react ()
-  (let* ((node (js2-node-at-point (1- (point))))
-         (args (js2-call-node-args node))
-         (methods (first args))
-         (parent (js2-node-parent node)))
-    (when (js2-object-node-p methods)
-      (let ((subject (cond ((js2-var-init-node-p parent)
-                            (js2-var-init-node-target parent))
-                           ((js2-assign-node-p parent)
-                            (js2-assign-node-left parent)))))
-        (when subject
-          (js2-record-object-literal methods
-                                     (js2-compute-nested-prop-get subject)
-                                     (js2-node-abs-pos methods)))))))
-
-(defalias 'js2-imenu-record-backbone-extend 'js2-imenu-record-backbone-or-react)
-
-(defalias 'js2-imenu-record-react-class 'js2-imenu-record-backbone-or-react)
-
-(defun js2-imenu-record-enyo-kind ()
-  (let* ((node (js2-node-at-point (1- (point))))
-         (args (js2-call-node-args node))
-         (options (first args)))
-    (when (js2-object-node-p options)
-      (let ((name-value
-             (loop for elem in (js2-object-node-elems options)
-                   thereis
-                   (let ((key (js2-object-prop-node-left elem))
-                         (value (js2-object-prop-node-right elem)))
-                     (when (and (equal
-                                 (cond ((js2-name-node-p key)
-                                        (js2-name-node-name key))
-                                       ((js2-string-node-p key)
-                                        (js2-string-node-value key)))
-                                 "name")
-                                (js2-string-node-p value))
-                       (js2-string-node-value value))))))
-        (when name-value
-          (js2-record-object-literal options
-                                     (if js2-imenu-split-string-identifiers
-                                         (split-string name-value "\\.")
-                                       (list name-value))
-                                     (js2-node-abs-pos options)))))))
-
-(defun js2-imenu-record-sencha-class ()
-  (let* ((node (js2-node-at-point (1- (point))))
-         (args (js2-call-node-args node))
-         (name (first args))
-         (methods (second args)))
-    (when (and (js2-string-node-p name) (js2-object-node-p methods))
-      (let ((name-value (js2-string-node-value name)))
-        (js2-record-object-literal methods
-                                   (if js2-imenu-split-string-identifiers
-                                       (split-string name-value "\\." t)
-                                     (list name-value))
-                                   (js2-node-abs-pos methods))))))
-
-(defun js2-imenu-walk-ast ()
-  (js2-visit-ast
-   js2-mode-ast
-   (lambda (node end-p)
-     (unless end-p
-       (cond
-        ((and js2-imenu-show-other-functions
-              (js2-object-prop-node-p node))
-         (js2-imenu-record-orphan-prop-node-function node))
-        ((js2-assign-node-p node)
-         (cond
-          ((and js2-imenu-show-other-functions
-                (js2-function-node-p
-                 (js2-assign-node-right node)))
-           (js2-imenu-record-orphan-assign-node-function
-            (js2-assign-node-left node)
-            (js2-assign-node-right node)))
-          ((and js2-imenu-show-module-pattern
-                (js2-call-node-p
-                 (js2-assign-node-right node)))
-           (js2-imenu-record-module-pattern
-            (js2-assign-node-left node)
-            (js2-assign-node-right node)))))
-        ((js2-var-init-node-p node)
-         (cond
-          ((and js2-imenu-show-other-functions
-                (js2-function-node-p
-                 (js2-var-init-node-initializer node)))
-           (js2-imenu-record-orphan-assign-node-function
-            (js2-var-init-node-target node)
-            (js2-var-init-node-initializer node)))
-          ((and js2-imenu-show-module-pattern
-                (js2-call-node-p
-                 (js2-var-init-node-initializer node)))
-           (js2-imenu-record-module-pattern
-            (js2-var-init-node-target node)
-            (js2-var-init-node-initializer node))))))
-       t))))
-
-(defun js2-imenu-parent-key-names (node)
-  "Get the list of parent key names of NODE.
-
-For example, for code
-
-  {rules: {password: {required: function() {}}}}
-
-when NODE is the inner `js2-object-prop-mode',
-it returns `(\"rules\" \"password\")'."
-  (let (rlt (n node))
-    (while (setq n (js2-imenu-parent-prop-node n))
-      (push (js2-prop-node-name (js2-object-prop-node-left n)) rlt))
-    rlt))
-
-(defun js2-imenu-parent-prop-node (node)
-  "When the parent of NODE is `js2-object-node',
-and the grandparent is `js2-object-prop-node',
-return the grandparent."
-  ;; Suppose the code is:
-  ;; {parent-key: {required: function() {}}}
-  ;; NODE is `required: function() {}'.
-  (let (p2 p3)
-    ;; Parent is `{required: function() {}}'.
-    (setq p2 (js2-node-parent node))
-    ;; GP is `parent-key: {required: function() {}}'.
-    (when (and p2 (js2-object-node-p p2))
-      (setq p3 (js2-node-parent p2))
-      (if (and p3 (js2-object-prop-node-p p3)) p3))))
-
-(defun js2-imenu-record-orphan-prop-node-function (node)
-  "Record orphan function when it's the value of NODE.
-NODE must be `js2-object-prop-node'."
-  (when (js2-function-node-p (js2-object-prop-node-right node))
-    (let ((fn-node (js2-object-prop-node-right node)))
-      (unless (and js2-imenu-function-map
-                   (gethash fn-node js2-imenu-function-map))
-        (let ((key-node (js2-object-prop-node-left node))
-              (parent-prop-node (js2-imenu-parent-prop-node node))
-              chain)
-          (setq chain (nconc (js2-imenu-parent-key-names node)
-                             (list (js2-prop-node-name key-node))))
-          (push js2-imenu-other-functions-ns chain)
-          (js2-record-imenu-entry fn-node chain
-                                  (js2-node-abs-pos key-node)))))))
-
-(defun js2-imenu-record-orphan-assign-node-function (target-node fn-node)
-  "Record orphan function FN-NODE assigned to node TARGET."
-  (when (or (not js2-imenu-function-map)
-            (eq 'skip
-                (gethash fn-node js2-imenu-function-map 'skip)))
-    (let ((chain (js2-compute-nested-prop-get target-node)))
-      (when chain
-        (push js2-imenu-other-functions-ns chain)
-        (js2-record-imenu-entry fn-node chain (js2-node-abs-pos fn-node))))))
-
-(defun js2-imenu-record-module-pattern (target init)
-  "Recognize and record module pattern use instance.
-INIT must be `js2-call-node'."
-  (let ((callt (js2-call-node-target init)))
-    ;; Just basic call form: (function() {...})();
-    ;; TODO: Handle variations without duplicating `js2-wrapper-function-p'?
-    (when (and (js2-paren-node-p callt)
-               (js2-function-node-p (js2-paren-node-expr callt)))
-      (let* ((fn (js2-paren-node-expr callt))
-             (blk (js2-function-node-body fn))
-             (ret (car (last (js2-block-node-kids blk)))))
-        (when (and (js2-return-node-p ret)
-                   (js2-object-node-p (js2-return-node-retval ret)))
-          ;; TODO: Map function names when revealing module pattern is used.
-          (let ((retval (js2-return-node-retval ret))
-                (target-qname (js2-compute-nested-prop-get target)))
-            (js2-record-object-literal retval target-qname
-                                       (js2-node-abs-pos retval))
-            (js2-record-imenu-entry fn target-qname
-                                    (js2-node-abs-pos target))))))))
-
-;;;###autoload
-(define-minor-mode js2-imenu-extras-mode
-  "Toggle Imenu support for frameworks and structural patterns."
-  :lighter ""
-  (if js2-imenu-extras-mode
-      (js2-imenu-extras-setup)
-    (js2-imenu-extras-remove)))
-
-(provide 'js2-imenu-extras)
diff --git a/elpa/js2-mode-20190815.1327/js2-imenu-extras.elc b/elpa/js2-mode-20190815.1327/js2-imenu-extras.elc
deleted file mode 100644
index 698ac67a..00000000
Binary files a/elpa/js2-mode-20190815.1327/js2-imenu-extras.elc and /dev/null differ
diff --git a/elpa/js2-mode-20190815.1327/js2-mode-autoloads.el b/elpa/js2-mode-20190815.1327/js2-mode-autoloads.el
deleted file mode 100644
index ccea7e09..00000000
--- a/elpa/js2-mode-20190815.1327/js2-mode-autoloads.el
+++ /dev/null
@@ -1,85 +0,0 @@
-;;; js2-mode-autoloads.el --- automatically extracted autoloads
-;;
-;;; Code:
-
-(add-to-list 'load-path (directory-file-name
-                         (or (file-name-directory #$) (car load-path))))
-
-
-;;;### (autoloads nil "js2-imenu-extras" "js2-imenu-extras.el" (0
-;;;;;;  0 0 0))
-;;; Generated autoloads from js2-imenu-extras.el
-
-(autoload 'js2-imenu-extras-setup "js2-imenu-extras" "\
-
-
-\(fn)" nil nil)
-
-(autoload 'js2-imenu-extras-mode "js2-imenu-extras" "\
-Toggle Imenu support for frameworks and structural patterns.
-
-\(fn &optional ARG)" t nil)
-
-(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "js2-imenu-extras" '("js2-imenu-")))
-
-;;;***
-
-;;;### (autoloads nil "js2-mode" "js2-mode.el" (0 0 0 0))
-;;; Generated autoloads from js2-mode.el
-
-(autoload 'js2-highlight-unused-variables-mode "js2-mode" "\
-Toggle highlight of unused variables.
-
-\(fn &optional ARG)" t nil)
-
-(autoload 'js2-minor-mode "js2-mode" "\
-Minor mode for running js2 as a background linter.
-This allows you to use a different major mode for JavaScript editing,
-such as `js-mode', while retaining the asynchronous error/warning
-highlighting features of `js2-mode'.
-
-\(fn &optional ARG)" t nil)
-
-(autoload 'js2-mode "js2-mode" "\
-Major mode for editing JavaScript code.
-
-\(fn)" t nil)
-
-(autoload 'js2-jsx-mode "js2-mode" "\
-Major mode for editing JSX code in Emacs 26 and earlier.
-
-To edit JSX code in Emacs 27, use `js-mode' as your major mode
-with `js2-minor-mode' enabled.
-
-To customize the indentation for this mode, set the SGML offset
-variables (`sgml-basic-offset' et al) locally, like so:
-
-  (defun set-jsx-indentation ()
-    (setq-local sgml-basic-offset js2-basic-offset))
-  (add-hook \\='js2-jsx-mode-hook #\\='set-jsx-indentation)
-
-\(fn)" t nil)
-
-(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "js2-mode" '("js2-")))
-
-;;;***
-
-;;;### (autoloads nil "js2-old-indent" "js2-old-indent.el" (0 0 0
-;;;;;;  0))
-;;; Generated autoloads from js2-old-indent.el
-
-(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "js2-old-indent" '("js2-")))
-
-;;;***
-
-;;;### (autoloads nil nil ("js2-mode-pkg.el") (0 0 0 0))
-
-;;;***
-
-;; Local Variables:
-;; version-control: never
-;; no-byte-compile: t
-;; no-update-autoloads: t
-;; coding: utf-8
-;; End:
-;;; js2-mode-autoloads.el ends here
diff --git a/elpa/js2-mode-20190815.1327/js2-mode-pkg.el b/elpa/js2-mode-20190815.1327/js2-mode-pkg.el
deleted file mode 100644
index 1db2b805..00000000
--- a/elpa/js2-mode-20190815.1327/js2-mode-pkg.el
+++ /dev/null
@@ -1,15 +0,0 @@
-(define-package "js2-mode" "20190815.1327" "Improved JavaScript editing mode"
-  '((emacs "24.1")
-    (cl-lib "0.5"))
-  :keywords
-  '("languages" "javascript")
-  :authors
-  '(("Steve Yegge" . "steve.yegge@gmail.com")
-    ("mooz" . "stillpedant@gmail.com")
-    ("Dmitry Gutov" . "dgutov@yandex.ru"))
-  :maintainer
-  '("Steve Yegge" . "steve.yegge@gmail.com")
-  :url "https://github.com/mooz/js2-mode/")
-;; Local Variables:
-;; no-byte-compile: t
-;; End:
diff --git a/elpa/js2-mode-20190815.1327/js2-mode.el b/elpa/js2-mode-20190815.1327/js2-mode.el
deleted file mode 100644
index c05be211..00000000
--- a/elpa/js2-mode-20190815.1327/js2-mode.el
+++ /dev/null
@@ -1,12940 +0,0 @@
-;;; js2-mode.el --- Improved JavaScript editing mode -*- lexical-binding: t -*-
-
-;; Copyright (C) 2009, 2011-2018  Free Software Foundation, Inc.
-
-;; Author: Steve Yegge <steve.yegge@gmail.com>
-;;         mooz <stillpedant@gmail.com>
-;;         Dmitry Gutov <dgutov@yandex.ru>
-;; URL:  https://github.com/mooz/js2-mode/
-;;       http://code.google.com/p/js2-mode/
-;; Version: 20190219
-;; Keywords: languages, javascript
-;; Package-Requires: ((emacs "24.1") (cl-lib "0.5"))
-
-;; This file is part of GNU Emacs.
-
-;; GNU Emacs is free software: you can redistribute it and/or modify
-;; it under the terms of the GNU General Public License as published by
-;; the Free Software Foundation, either version 3 of the License, or
-;; (at your option) any later version.
-
-;; GNU Emacs is distributed in the hope that it will be useful,
-;; but WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-;; GNU General Public License for more details.
-
-;; You should have received a copy of the GNU General Public License
-;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
-
-;;; Commentary:
-
-;; This JavaScript editing mode supports:
-
-;;  - strict recognition of the Ecma-262 language standard
-;;  - support for most Rhino and SpiderMonkey extensions from 1.5 and up
-;;  - parsing support for ECMAScript for XML (E4X, ECMA-357)
-;;  - accurate syntax highlighting using a recursive-descent parser
-;;  - on-the-fly reporting of syntax errors and strict-mode warnings
-;;  - undeclared-variable warnings using a configurable externs framework
-;;  - "bouncing" line indentation to choose among alternate indentation points
-;;  - smart line-wrapping within comments and strings
-;;  - code folding:
-;;    - show some or all function bodies as {...}
-;;    - show some or all block comments as /*...*/
-;;  - context-sensitive menu bar and popup menus
-;;  - code browsing using the `imenu' package
-;;  - many customization options
-
-;; Installation:
-;;
-;; To install it as your major mode for JavaScript editing:
-
-;;   (add-to-list 'auto-mode-alist '("\\.js\\'" . js2-mode))
-
-;; Alternatively, to install it as a minor mode just for JavaScript linting,
-;; you must add it to the appropriate major-mode hook.  Normally this would be:
-
-;;   (add-hook 'js-mode-hook 'js2-minor-mode)
-
-;; You may also want to hook it in for shell scripts running via node.js:
-
-;;   (add-to-list 'interpreter-mode-alist '("node" . js2-mode))
-
-;; Use Emacs 27 and want to write JSX?  Then use `js2-minor-mode' as described
-;; above.  Use Emacs 26 or earlier?  Then use `js2-jsx-mode':
-
-;;   (add-to-list 'auto-mode-alist '("\\.jsx?\\'" . js2-jsx-mode))
-;;   (add-to-list 'interpreter-mode-alist '("node" . js2-jsx-mode))
-
-;; Note that linting of JSX code may fail in both modes.
-
-;; To customize how it works:
-;;   M-x customize-group RET js2-mode RET
-
-;; Notes:
-
-;; This mode includes a port of Mozilla Rhino's scanner, parser and
-;; symbol table.  Ideally it should stay in sync with Rhino, keeping
-;; `js2-mode' current as the EcmaScript language standard evolves.
-
-;; Unlike cc-engine based language modes, js2-mode's line-indentation is not
-;; customizable.  It is a surprising amount of work to support customizable
-;; indentation.  The current compromise is that the tab key lets you cycle among
-;; various likely indentation points, similar to the behavior of python-mode.
-
-;; This mode does not yet work with "multi-mode" modes such as `mmm-mode'
-;; and `mumamo', although it could be made to do so with some effort.
-;; This means that `js2-mode' is currently only useful for editing JavaScript
-;; files, and not for editing JavaScript within <script> tags or templates.
-
-;; The project page on GitHub is used for development and issue tracking.
-;; The original homepage at Google Code has outdated information and is mostly
-;; unmaintained.
-
-;;; Code:
-
-(require 'cl-lib)
-(require 'imenu)
-(require 'js)
-(require 'etags)
-
-(eval-and-compile
-  (if (version< emacs-version "25.0")
-      (require 'js2-old-indent)
-    (defvaralias 'js2-basic-offset 'js-indent-level nil)
-    (defalias 'js2-proper-indentation 'js--proper-indentation)
-    (defalias 'js2-jsx-indent-line 'js-jsx-indent-line)
-    (defalias 'js2-indent-line 'js-indent-line)
-    (defalias 'js2-re-search-forward 'js--re-search-forward)))
-
-;;; Externs (variables presumed to be defined by the host system)
-
-(defvar js2-ecma-262-externs
-  (mapcar 'symbol-name
-          '(Array Boolean Date Error EvalError Function Infinity JSON
-          Math NaN Number Object RangeError ReferenceError RegExp
-          String SyntaxError TypeError URIError
-          decodeURI decodeURIComponent encodeURI
-          encodeURIComponent escape eval isFinite isNaN
-          parseFloat parseInt undefined unescape))
-"Ecma-262 externs.  Never highlighted as undeclared variables.")
-
-(defvar js2-browser-externs
-  (mapcar 'symbol-name
-          '(;; DOM level 1
-            Attr CDATASection CharacterData Comment DOMException
-            DOMImplementation Document DocumentFragment
-            DocumentType Element Entity EntityReference
-            ExceptionCode NamedNodeMap Node NodeList Notation
-            ProcessingInstruction Text
-
-            ;; DOM level 2
-            HTMLAnchorElement HTMLAppletElement HTMLAreaElement
-            HTMLBRElement HTMLBaseElement HTMLBaseFontElement
-            HTMLBodyElement HTMLButtonElement HTMLCollection
-            HTMLDListElement HTMLDirectoryElement HTMLDivElement
-            HTMLDocument HTMLElement HTMLFieldSetElement
-            HTMLFontElement HTMLFormElement HTMLFrameElement
-            HTMLFrameSetElement HTMLHRElement HTMLHeadElement
-            HTMLHeadingElement HTMLHtmlElement HTMLIFrameElement
-            HTMLImageElement HTMLInputElement HTMLIsIndexElement
-            HTMLLIElement HTMLLabelElement HTMLLegendElement
-            HTMLLinkElement HTMLMapElement HTMLMenuElement
-            HTMLMetaElement HTMLModElement HTMLOListElement
-            HTMLObjectElement HTMLOptGroupElement
-            HTMLOptionElement HTMLOptionsCollection
-            HTMLParagraphElement HTMLParamElement HTMLPreElement
-            HTMLQuoteElement HTMLScriptElement HTMLSelectElement
-            HTMLStyleElement HTMLTableCaptionElement
-            HTMLTableCellElement HTMLTableColElement
-            HTMLTableElement HTMLTableRowElement
-            HTMLTableSectionElement HTMLTextAreaElement
-            HTMLTitleElement HTMLUListElement
-
-            ;; DOM level 3
-            DOMConfiguration DOMError DOMException
-            DOMImplementationList DOMImplementationSource
-            DOMLocator DOMStringList NameList TypeInfo
-            UserDataHandler
-
-            ;; Window
-            window alert confirm document java navigator prompt screen
-            self top requestAnimationFrame cancelAnimationFrame
-
-            ;; W3C CSS
-            CSSCharsetRule CSSFontFace CSSFontFaceRule
-            CSSImportRule CSSMediaRule CSSPageRule
-            CSSPrimitiveValue CSSProperties CSSRule CSSRuleList
-            CSSStyleDeclaration CSSStyleRule CSSStyleSheet
-            CSSValue CSSValueList Counter DOMImplementationCSS
-            DocumentCSS DocumentStyle ElementCSSInlineStyle
-            LinkStyle MediaList RGBColor Rect StyleSheet
-            StyleSheetList ViewCSS
-
-            ;; W3C Event
-            EventListener EventTarget Event DocumentEvent UIEvent
-            MouseEvent MutationEvent KeyboardEvent
-
-            ;; W3C Range
-            DocumentRange Range RangeException
-
-            ;; W3C XML
-            XPathResult XMLHttpRequest
-
-            ;; console object.  Provided by at least Chrome and Firefox.
-            console))
-  "Browser externs.
-You can cause these to be included or excluded with the custom
-variable `js2-include-browser-externs'.")
-
-(defvar js2-rhino-externs
-  (mapcar 'symbol-name
-          '(Packages importClass importPackage com org java
-            ;; Global object (shell) externs.
-            defineClass deserialize doctest gc help load
-            loadClass print quit readFile readUrl runCommand seal
-            serialize spawn sync toint32 version))
-  "Mozilla Rhino externs.
-Set `js2-include-rhino-externs' to t to include them.")
-
-(defvar js2-node-externs
-  (mapcar 'symbol-name
-          '(__dirname __filename Buffer clearInterval clearTimeout require
-            console exports global module process setInterval setTimeout
-            querystring setImmediate clearImmediate))
-  "Node.js externs.
-Set `js2-include-node-externs' to t to include them.")
-
-(defvar js2-typed-array-externs
-  (mapcar 'symbol-name
-          '(ArrayBuffer Uint8ClampedArray DataView
-            Int8Array Uint8Array Int16Array Uint16Array Int32Array Uint32Array
-            Float32Array Float64Array))
-  "Khronos typed array externs. Available in most modern browsers and
-in node.js >= 0.6. If `js2-include-node-externs' or `js2-include-browser-externs'
-are enabled, these will also be included.")
-
-(defvar js2-harmony-externs
-  (mapcar 'symbol-name
-          '(Map Promise Proxy Reflect Set Symbol WeakMap WeakSet))
-  "ES6 externs.  If `js2-include-browser-externs' is enabled and
-`js2-language-version' is sufficiently high, these will be included.")
-
-;;; Variables
-
-(defcustom js2-ignored-warnings nil
-  "A list of warning message types that will not be reported.
-
-Possible values are the keys of `js2-message-table'."
-  :group 'js2-mode
-  :type '(repeat string))
-
-(defcustom js2-highlight-level 2
-  "Amount of syntax highlighting to perform.
-0 or a negative value means none.
-1 adds basic syntax highlighting.
-2 adds highlighting of some Ecma built-in properties.
-3 adds highlighting of many Ecma built-in functions."
-  :group 'js2-mode
-  :type '(choice (const :tag "None" 0)
-                 (const :tag "Basic" 1)
-                 (const :tag "Include Properties" 2)
-                 (const :tag "Include Functions" 3)))
-
-(defvar js2-mode-dev-mode-p nil
-  "Non-nil if running in development mode.  Normally nil.")
-
-(defgroup js2-mode nil
-  "An improved JavaScript mode."
-  :group 'languages)
-
-(defcustom js2-idle-timer-delay 0.2
-  "Delay in secs before re-parsing after user makes changes.
-Multiplied by `js2-dynamic-idle-timer-adjust', which see."
-  :type 'number
-  :group 'js2-mode)
-(make-variable-buffer-local 'js2-idle-timer-delay)
-
-(defcustom js2-dynamic-idle-timer-adjust 0
-  "Positive to adjust `js2-idle-timer-delay' based on file size.
-The idea is that for short files, parsing is faster so we can be
-more responsive to user edits without interfering with editing.
-The buffer length in characters (typically bytes) is divided by
-this value and used to multiply `js2-idle-timer-delay' for the
-buffer.  For example, a 21k file and 10k adjust yields 21k/10k
-== 2, so js2-idle-timer-delay is multiplied by 2.
-If `js2-dynamic-idle-timer-adjust' is 0 or negative,
-`js2-idle-timer-delay' is not dependent on the file size."
-  :type 'number
-  :group 'js2-mode)
-
-(defcustom js2-concat-multiline-strings t
-  "When non-nil, `js2-line-break' in mid-string will make it a
-string concatenation. When `eol', the '+' will be inserted at the
-end of the line, otherwise, at the beginning of the next line."
-  :type '(choice (const t) (const eol) (const nil))
-  :group 'js2-mode)
-
-(defcustom js2-mode-show-parse-errors t
-  "True to highlight parse errors."
-  :type 'boolean
-  :group 'js2-mode)
-
-(defcustom js2-mode-assume-strict nil
-  "Non-nil to start files in strict mode automatically."
-  :type 'boolean
-  :group 'js2-mode)
-
-(defcustom js2-mode-show-strict-warnings t
-  "Non-nil to emit Ecma strict-mode warnings.
-Some of the warnings can be individually disabled by other flags,
-even if this flag is non-nil."
-  :type 'boolean
-  :group 'js2-mode)
-
-(defcustom js2-strict-trailing-comma-warning nil
-  "Non-nil to warn about trailing commas in array literals.
-Ecma-262-5.1 allows them, but older versions of IE raise an error."
-  :type 'boolean
-  :group 'js2-mode)
-
-(defcustom js2-strict-missing-semi-warning t
-  "Non-nil to warn about semicolon auto-insertion after statement.
-Technically this is legal per Ecma-262, but some style guides disallow
-depending on it."
-  :type 'boolean
-  :group 'js2-mode)
-
-(defcustom js2-missing-semi-one-line-override nil
-  "Non-nil to permit missing semicolons in one-line functions.
-In one-liner functions such as `function identity(x) {return x}'
-people often omit the semicolon for a cleaner look.  If you are
-such a person, you can suppress the missing-semicolon warning
-by setting this variable to t."
-  :type 'boolean
-  :group 'js2-mode)
-
-(defcustom js2-strict-inconsistent-return-warning t
-  "Non-nil to warn about mixing returns with value-returns.
-It's perfectly legal to have a `return' and a `return foo' in the
-same function, but it's often an indicator of a bug, and it also
-interferes with type inference (in systems that support it.)"
-  :type 'boolean
-  :group 'js2-mode)
-
-(defcustom js2-strict-cond-assign-warning t
-  "Non-nil to warn about expressions like if (a = b).
-This often should have been '==' instead of '='.  If the warning
-is enabled, you can suppress it on a per-expression basis by
-parenthesizing the expression, e.g. if ((a = b)) ..."
-  :type 'boolean
-  :group 'js2-mode)
-
-(defcustom js2-strict-var-redeclaration-warning t
-  "Non-nil to warn about redeclaring variables in a script or function."
-  :type 'boolean
-  :group 'js2-mode)
-
-(defcustom js2-strict-var-hides-function-arg-warning t
-  "Non-nil to warn about a var decl hiding a function argument."
-  :type 'boolean
-  :group 'js2-mode)
-
-(defcustom js2-skip-preprocessor-directives nil
-  "Non-nil to treat lines beginning with # as comments.
-Useful for viewing Mozilla JavaScript source code."
-  :type 'boolean
-  :group 'js2-mode)
-
-(defcustom js2-language-version 200
-  "Configures what JavaScript language version to recognize.
-Currently versions 150, 160, 170, 180 and 200 are supported,
-corresponding to JavaScript 1.5, 1.6, 1.7, 1.8 and 2.0 (Harmony),
-respectively.  In a nutshell, 1.6 adds E4X support, 1.7 adds let,
-yield, and Array comprehensions, and 1.8 adds function closures."
-  :type 'integer
-  :group 'js2-mode)
-
-(defcustom js2-instanceof-has-side-effects nil
-  "If non-nil, treats the instanceof operator as having side effects.
-This is useful for xulrunner apps."
-  :type 'boolean
-  :group 'js2-mode)
-
-(defcustom js2-getprop-has-side-effects nil
-  "If non-nil, treats the getprop operator as having side effects.
-This is useful for testing libraries with nontrivial getters and for
-compilers that use empty getprops to declare interface properties."
-  :type 'boolean
-  :group 'js2-mode)
-
-(defcustom js2-move-point-on-right-click t
-  "Non-nil to move insertion point when you right-click.
-This makes right-click context menu behavior a bit more intuitive,
-since menu operations generally apply to the point.  The exception
-is if there is a region selection, in which case the point does -not-
-move, so cut/copy/paste can work properly.
-
-Note that IntelliJ moves the point, and Eclipse leaves it alone,
-so this behavior is customizable."
-  :group 'js2-mode
-  :type 'boolean)
-
-(defcustom js2-allow-rhino-new-expr-initializer t
-  "Non-nil to support a Rhino's experimental syntactic construct.
-
-Rhino supports the ability to follow a `new' expression with an object
-literal, which is used to set additional properties on the new object
-after calling its constructor.  Syntax:
-
-  new <expr> [ ( arglist ) ] [initializer]
-
-Hence, this expression:
-
-  new Object {a: 1, b: 2}
-
-results in an Object with properties a=1 and b=2.  This syntax is
-apparently not configurable in Rhino - it's currently always enabled,
-as of Rhino version 1.7R2."
-  :type 'boolean
-  :group 'js2-mode)
-
-(defcustom js2-allow-member-expr-as-function-name nil
-  "Non-nil to support experimental Rhino syntax for function names.
-
-Rhino supports an experimental syntax configured via the Rhino Context
-setting `allowMemberExprAsFunctionName'.  The experimental syntax is:
-
-  function <member-expr> ( [ arg-list ] ) { <body> }
-
-Where member-expr is a non-parenthesized 'member expression', which
-is anything at the grammar level of a new-expression or lower, meaning
-any expression that does not involve infix or unary operators.
-
-When <member-expr> is not a simple identifier, then it is syntactic
-sugar for assigning the anonymous function to the <member-expr>.  Hence,
-this code:
-
-  function a.b().c[2] (x, y) { ... }
-
-is rewritten as:
-
-  a.b().c[2] = function(x, y) {...}
-
-which doesn't seem particularly useful, but Rhino permits it."
-  :type 'boolean
-  :group 'js2-mode)
-
-;; scanner variables
-
-(defmacro js2-deflocal (name value &optional comment)
-  "Define a buffer-local variable NAME with VALUE and COMMENT."
-  (declare (debug defvar) (doc-string 3))
-  `(progn
-     (defvar ,name ,value ,comment)
-     (make-variable-buffer-local ',name)))
-
-(defvar js2-EOF_CHAR -1
-  "Represents end of stream.  Distinct from js2-EOF token type.")
-
-;; I originally used symbols to represent tokens, but Rhino uses
-;; ints and then sets various flag bits in them, so ints it is.
-;; The upshot is that we need a `js2-' prefix in front of each name.
-(defvar js2-ERROR -1)
-(defvar js2-EOF 0)
-(defvar js2-EOL 1)
-(defvar js2-ENTERWITH 2)       ; begin interpreter bytecodes
-(defvar js2-LEAVEWITH 3)
-(defvar js2-RETURN 4)
-(defvar js2-GOTO 5)
-(defvar js2-IFEQ 6)
-(defvar js2-IFNE 7)
-(defvar js2-SETNAME 8)
-(defvar js2-BITOR 9)
-(defvar js2-BITXOR 10)
-(defvar js2-BITAND 11)
-(defvar js2-EQ 12)
-(defvar js2-NE 13)
-(defvar js2-LT 14)
-(defvar js2-LE 15)
-(defvar js2-GT 16)
-(defvar js2-GE 17)
-(defvar js2-LSH 18)
-(defvar js2-RSH 19)
-(defvar js2-URSH 20)
-(defvar js2-ADD 21)            ; infix plus
-(defvar js2-SUB 22)            ; infix minus
-(defvar js2-MUL 23)
-(defvar js2-DIV 24)
-(defvar js2-MOD 25)
-(defvar js2-NOT 26)
-(defvar js2-BITNOT 27)
-(defvar js2-POS 28)            ; unary plus
-(defvar js2-NEG 29)            ; unary minus
-(defvar js2-NEW 30)
-(defvar js2-DELPROP 31)
-(defvar js2-TYPEOF 32)
-(defvar js2-GETPROP 33)
-(defvar js2-GETPROPNOWARN 34)
-(defvar js2-SETPROP 35)
-(defvar js2-GETELEM 36)
-(defvar js2-SETELEM 37)
-(defvar js2-CALL 38)
-(defvar js2-NAME 39)           ; an identifier
-(defvar js2-NUMBER 40)
-(defvar js2-STRING 41)
-(defvar js2-NULL 42)
-(defvar js2-THIS 43)
-(defvar js2-FALSE 44)
-(defvar js2-TRUE 45)
-(defvar js2-SHEQ 46)           ; shallow equality (===)
-(defvar js2-SHNE 47)           ; shallow inequality (!==)
-(defvar js2-REGEXP 48)
-(defvar js2-BINDNAME 49)
-(defvar js2-THROW 50)
-(defvar js2-RETHROW 51)        ; rethrow caught exception: catch (e if ) uses it
-(defvar js2-IN 52)
-(defvar js2-INSTANCEOF 53)
-(defvar js2-LOCAL_LOAD 54)
-(defvar js2-GETVAR 55)
-(defvar js2-SETVAR 56)
-(defvar js2-CATCH_SCOPE 57)
-(defvar js2-ENUM_INIT_KEYS 58) ; FIXME: what are these?
-(defvar js2-ENUM_INIT_VALUES 59)
-(defvar js2-ENUM_INIT_ARRAY 60)
-(defvar js2-ENUM_NEXT 61)
-(defvar js2-ENUM_ID 62)
-(defvar js2-THISFN 63)
-(defvar js2-RETURN_RESULT 64)  ; to return previously stored return result
-(defvar js2-ARRAYLIT 65)       ; array literal
-(defvar js2-OBJECTLIT 66)      ; object literal
-(defvar js2-GET_REF 67)        ; *reference
-(defvar js2-SET_REF 68)        ; *reference = something
-(defvar js2-DEL_REF 69)        ; delete reference
-(defvar js2-REF_CALL 70)       ; f(args) = something or f(args)++
-(defvar js2-REF_SPECIAL 71)    ; reference for special properties like __proto
-(defvar js2-YIELD 72)          ; JS 1.7 yield pseudo keyword
-
-;; XML support
-(defvar js2-DEFAULTNAMESPACE 73)
-(defvar js2-ESCXMLATTR 74)
-(defvar js2-ESCXMLTEXT 75)
-(defvar js2-REF_MEMBER 76)     ; Reference for x.@y, x..y etc.
-(defvar js2-REF_NS_MEMBER 77)  ; Reference for x.ns::y, x..ns::y etc.
-(defvar js2-REF_NAME 78)       ; Reference for @y, @[y] etc.
-(defvar js2-REF_NS_NAME 79)    ; Reference for ns::y, @ns::y@[y] etc.
-
-(defvar js2-first-bytecode js2-ENTERWITH)
-(defvar js2-last-bytecode js2-REF_NS_NAME)
-
-(defvar js2-TRY 80)
-(defvar js2-SEMI 81)           ; semicolon
-(defvar js2-LB 82)             ; left and right brackets
-(defvar js2-RB 83)
-(defvar js2-LC 84)             ; left and right curly-braces
-(defvar js2-RC 85)
-(defvar js2-LP 86)             ; left and right parens
-(defvar js2-RP 87)
-(defvar js2-COMMA 88)          ; comma operator
-
-(defvar js2-ASSIGN 89)         ; simple assignment (=)
-(defvar js2-ASSIGN_BITOR 90)   ; |=
-(defvar js2-ASSIGN_BITXOR 91)  ; ^=
-(defvar js2-ASSIGN_BITAND 92)  ; &=
-(defvar js2-ASSIGN_LSH 93)     ; <<=
-(defvar js2-ASSIGN_RSH 94)     ; >>=
-(defvar js2-ASSIGN_URSH 95)    ; >>>=
-(defvar js2-ASSIGN_ADD 96)     ; +=
-(defvar js2-ASSIGN_SUB 97)     ; -=
-(defvar js2-ASSIGN_MUL 98)     ; *=
-(defvar js2-ASSIGN_DIV 99)     ; /=
-(defvar js2-ASSIGN_MOD 100)    ; %=
-(defvar js2-ASSIGN_EXPON 101)
-
-(defvar js2-first-assign js2-ASSIGN)
-(defvar js2-last-assign js2-ASSIGN_EXPON)
-
-(defvar js2-COLON 102)
-(defvar js2-OR 103)            ; logical or (||)
-(defvar js2-AND 104)           ; logical and (&&)
-(defvar js2-INC 105)           ; increment/decrement (++ --)
-(defvar js2-DEC 106)
-(defvar js2-DOT 107)           ; member operator (.)
-(defvar js2-FUNCTION 108)      ; function keyword
-(defvar js2-EXPORT 109)        ; export keyword
-(defvar js2-IMPORT 110)        ; import keyword
-(defvar js2-IF 111)            ; if keyword
-(defvar js2-ELSE 112)          ; else keyword
-(defvar js2-SWITCH 113)        ; switch keyword
-(defvar js2-CASE 114)          ; case keyword
-(defvar js2-DEFAULT 115)       ; default keyword
-(defvar js2-WHILE 116)         ; while keyword
-(defvar js2-DO 117)            ; do keyword
-(defvar js2-FOR 118)           ; for keyword
-(defvar js2-BREAK 119)         ; break keyword
-(defvar js2-CONTINUE 120)      ; continue keyword
-(defvar js2-VAR 121)           ; var keyword
-(defvar js2-WITH 122)          ; with keyword
-(defvar js2-CATCH 123)         ; catch keyword
-(defvar js2-FINALLY 124)       ; finally keyword
-(defvar js2-VOID 125)          ; void keyword
-(defvar js2-RESERVED 126)      ; reserved keywords
-
-(defvar js2-EMPTY 127)
-
-;; Types used for the parse tree - never returned by scanner.
-
-(defvar js2-BLOCK 128)         ; statement block
-(defvar js2-LABEL 129)         ; label
-(defvar js2-TARGET 130)
-(defvar js2-LOOP 131)
-(defvar js2-EXPR_VOID 132)     ; expression statement in functions
-(defvar js2-EXPR_RESULT 133)   ; expression statement in scripts
-(defvar js2-JSR 134)
-(defvar js2-SCRIPT 135)        ; top-level node for entire script
-(defvar js2-TYPEOFNAME 136)    ; for typeof(simple-name)
-(defvar js2-USE_STACK 137)
-(defvar js2-SETPROP_OP 138)    ; x.y op= something
-(defvar js2-SETELEM_OP 139)    ; x[y] op= something
-(defvar js2-LOCAL_BLOCK 140)
-(defvar js2-SET_REF_OP 141)    ; *reference op= something
-
-;; For XML support:
-(defvar js2-DOTDOT 142)        ; member operator (..)
-(defvar js2-COLONCOLON 143)    ; namespace::name
-(defvar js2-XML 144)           ; XML type
-(defvar js2-DOTQUERY 145)      ; .() -- e.g., x.emps.emp.(name == "terry")
-(defvar js2-XMLATTR 146)       ; @
-(defvar js2-XMLEND 147)
-
-;; Optimizer-only tokens
-(defvar js2-TO_OBJECT 148)
-(defvar js2-TO_DOUBLE 149)
-
-(defvar js2-GET 150)           ; JS 1.5 get pseudo keyword
-(defvar js2-SET 151)           ; JS 1.5 set pseudo keyword
-(defvar js2-LET 152)           ; JS 1.7 let pseudo keyword
-(defvar js2-CONST 153)
-(defvar js2-SETCONST 154)
-(defvar js2-SETCONSTVAR 155)
-(defvar js2-ARRAYCOMP 156)
-(defvar js2-LETEXPR 157)
-(defvar js2-WITHEXPR 158)
-(defvar js2-DEBUGGER 159)
-
-(defvar js2-COMMENT 160)
-(defvar js2-TRIPLEDOT 161)     ; for rest parameter
-(defvar js2-ARROW 162)         ; function arrow (=>)
-(defvar js2-CLASS 163)
-(defvar js2-EXTENDS 164)
-(defvar js2-SUPER 165)
-(defvar js2-TEMPLATE_HEAD 166)    ; part of template literal before substitution
-(defvar js2-NO_SUBS_TEMPLATE 167) ; template literal without substitutions
-(defvar js2-TAGGED_TEMPLATE 168)  ; tagged template literal
-
-(defvar js2-AWAIT 169)  ; await (pseudo keyword)
-
-(defvar js2-HOOK 170)          ; conditional (?:)
-(defvar js2-OPTIONAL-CHAINING 171) ; optional chaining (?.prop obj?.[expr] func?.())
-(defvar js2-EXPON 172)
-
-(defconst js2-num-tokens (1+ js2-EXPON))
-
-(defconst js2-debug-print-trees nil)
-
-;; Rhino accepts any string or stream as input.  Emacs character
-;; processing works best in buffers, so we'll assume the input is a
-;; buffer.  JavaScript strings can be copied into temp buffers before
-;; scanning them.
-
-;; Buffer-local variables yield much cleaner code than using `defstruct'.
-;; They're the Emacs equivalent of instance variables, more or less.
-
-(js2-deflocal js2-ts-dirty-line nil
-  "Token stream buffer-local variable.
-Indicates stuff other than whitespace since start of line.")
-
-(js2-deflocal js2-ts-hit-eof nil
-  "Token stream buffer-local variable.")
-
-;; FIXME: Unused.
-(js2-deflocal js2-ts-line-start 0
-  "Token stream buffer-local variable.")
-
-(js2-deflocal js2-ts-lineno 1
-  "Token stream buffer-local variable.")
-
-;; FIXME: Unused.
-(js2-deflocal js2-ts-line-end-char -1
-  "Token stream buffer-local variable.")
-
-(js2-deflocal js2-ts-cursor 1  ; emacs buffers are 1-indexed
-  "Token stream buffer-local variable.
-Current scan position.")
-
-;; FIXME: Unused.
-(js2-deflocal js2-ts-is-xml-attribute nil
-  "Token stream buffer-local variable.")
-
-(js2-deflocal js2-ts-xml-is-tag-content nil
-  "Token stream buffer-local variable.")
-
-(js2-deflocal js2-ts-xml-open-tags-count 0
-  "Token stream buffer-local variable.")
-
-(js2-deflocal js2-ts-string-buffer nil
-  "Token stream buffer-local variable.
-List of chars built up while scanning various tokens.")
-
-(cl-defstruct (js2-token
-               (:constructor make-js2-token (beg)))
-  "Value returned from the token stream."
-  (type js2-EOF)
-  (beg 1)
-  (end -1)
-  (string "")
-  number
-  number-base
-  number-legacy-octal-p
-  regexp-flags
-  comment-type
-  follows-eol-p)
-
-;; Have to call `js2-init-scanner' to initialize the values.
-(js2-deflocal js2-ti-tokens nil)
-(js2-deflocal js2-ti-tokens-cursor nil)
-(js2-deflocal js2-ti-lookahead nil)
-
-(cl-defstruct (js2-ts-state
-               (:constructor make-js2-ts-state (&key (lineno js2-ts-lineno)
-                                                     (cursor js2-ts-cursor)
-                                                     (tokens (copy-sequence js2-ti-tokens))
-                                                     (tokens-cursor js2-ti-tokens-cursor)
-                                                     (lookahead js2-ti-lookahead))))
-  lineno
-  cursor
-  tokens
-  tokens-cursor
-  lookahead)
-
-;;; Parser variables
-
-(js2-deflocal js2-parsed-errors nil
-  "List of errors produced during scanning/parsing.")
-
-(js2-deflocal js2-parsed-warnings nil
-  "List of warnings produced during scanning/parsing.")
-
-(js2-deflocal js2-recover-from-parse-errors t
-  "Non-nil to continue parsing after a syntax error.
-
-In recovery mode, the AST will be built in full, and any error
-nodes will be flagged with appropriate error information.  If
-this flag is nil, a syntax error will result in an error being
-signaled.
-
-The variable is automatically buffer-local, because different
-modes that use the parser will need different settings.")
-
-(js2-deflocal js2-parse-hook nil
-  "List of callbacks for receiving parsing progress.")
-
-(defvar js2-parse-finished-hook nil
-  "List of callbacks to notify when parsing finishes.
-Not called if parsing was interrupted.")
-
-(js2-deflocal js2-is-eval-code nil
-  "True if we're evaluating code in a string.
-If non-nil, the tokenizer will record the token text, and the AST nodes
-will record their source text.  Off by default for IDE modes, since the
-text is available in the buffer.")
-
-(defvar js2-parse-ide-mode t
-  "Non-nil if the parser is being used for `js2-mode'.
-If non-nil, the parser will set text properties for fontification
-and the syntax table.  The value should be nil when using the
-parser as a frontend to an interpreter or byte compiler.")
-
-;;; Parser instance variables (buffer-local vars for js2-parse)
-
-(defconst js2-ti-after-eol (lsh 1 16)
-  "Flag:  first token of the source line.")
-
-;; Inline Rhino's CompilerEnvirons vars as buffer-locals.
-
-(js2-deflocal js2-compiler-generate-debug-info t)
-(js2-deflocal js2-compiler-use-dynamic-scope nil)
-(js2-deflocal js2-compiler-reserved-keywords-as-identifier nil)
-(js2-deflocal js2-compiler-xml-available t)
-(js2-deflocal js2-compiler-optimization-level 0)
-(js2-deflocal js2-compiler-generating-source t)
-(js2-deflocal js2-compiler-strict-mode nil)
-(js2-deflocal js2-compiler-report-warning-as-error nil)
-(js2-deflocal js2-compiler-generate-observer-count nil)
-(js2-deflocal js2-compiler-activation-names nil)
-
-;; SKIP:  sourceURI
-
-;; There's a compileFunction method in Context.java - may need it.
-(js2-deflocal js2-called-by-compile-function nil
-  "True if `js2-parse' was called by `js2-compile-function'.
-Will only be used when we finish implementing the interpreter.")
-
-;; SKIP:  ts  (we just call `js2-init-scanner' and use its vars)
-
-;; SKIP:  node factory - we're going to just call functions directly,
-;; and eventually go to a unified AST format.
-
-(js2-deflocal js2-nesting-of-function 0)
-
-(js2-deflocal js2-recorded-identifiers nil
-  "Tracks identifiers found during parsing.")
-
-(js2-deflocal js2-is-in-destructuring nil
-  "True while parsing destructuring expression.")
-
-(js2-deflocal js2-in-use-strict-directive nil
-  "True while inside a script or function under strict mode.")
-
-(defcustom js2-global-externs nil
-  "A list of any extern names you'd like to consider always declared.
-This list is global and is used by all `js2-mode' files.
-You can create buffer-local externs list using `js2-additional-externs'."
-  :type 'list
-  :group 'js2-mode)
-
-(defcustom js2-include-browser-externs t
-  "Non-nil to include browser externs in the master externs list.
-If you work on JavaScript files that are not intended for browsers,
-such as Mozilla Rhino server-side JavaScript, set this to nil.
-See `js2-additional-externs' for more information about externs."
-  :type 'boolean
-  :group 'js2-mode)
-
-(defcustom js2-include-rhino-externs nil
-  "Non-nil to include Mozilla Rhino externs in the master externs list.
-See `js2-additional-externs' for more information about externs."
-  :type 'boolean
-  :group 'js2-mode)
-
-(defcustom js2-include-node-externs nil
-  "Non-nil to include Node.js externs in the master externs list.
-See `js2-additional-externs' for more information about externs."
-  :type 'boolean
-  :group 'js2-mode)
-
-(js2-deflocal js2-additional-externs nil
-  "A buffer-local list of additional external declarations.
-It is used to decide whether variables are considered undeclared
-for purposes of highlighting.  See `js2-highlight-undeclared-vars'.
-
-Each entry is a Lisp string.  The string should be the fully qualified
-name of an external entity.  All externs should be added to this list,
-so that as js2-mode's processing improves it can take advantage of them.
-
-You may want to declare your externs in three ways.
-First, you can add externs that are valid for all your JavaScript files.
-You should probably do this by adding them to `js2-global-externs', which
-is a global list used for all js2-mode files.
-
-Next, you can add a function to `js2-init-hook' that adds additional
-externs appropriate for the specific file, perhaps based on its path.
-These should go in `js2-additional-externs', which is buffer-local.
-
-Third, you can use JSLint's global declaration, as long as
-`js2-include-jslint-globals' is non-nil, which see.
-
-Finally, you can add a function to `js2-post-parse-callbacks',
-which is called after parsing completes, and `js2-mode-ast' is bound to
-the root of the parse tree.  At this stage you can set up an AST
-node visitor using `js2-visit-ast' and examine the parse tree
-for specific import patterns that may imply the existence of
-other externs, possibly tied to your build system.  These should also
-be added to `js2-additional-externs'.
-
-Your post-parse callback may of course also use the simpler and
-faster (but perhaps less robust) approach of simply scanning the
-buffer text for your imports, using regular expressions.")
-
-(put 'js2-additional-externs 'safe-local-variable
-     (lambda (val) (cl-every #'stringp val)))
-
-;; SKIP:  decompiler
-;; SKIP:  encoded-source
-
-;;; The following variables are per-function and should be saved/restored
-;;; during function parsing...
-
-(js2-deflocal js2-current-script-or-fn nil)
-(js2-deflocal js2-current-scope nil)
-(js2-deflocal js2-nesting-of-with 0)
-(js2-deflocal js2-label-set nil
-  "An alist mapping label names to nodes.")
-
-(js2-deflocal js2-loop-set nil)
-(js2-deflocal js2-loop-and-switch-set nil)
-(js2-deflocal js2-has-return-value nil)
-(js2-deflocal js2-end-flags 0)
-
-;;; ...end of per function variables
-
-;; These flags enumerate the possible ways a statement/function can
-;; terminate. These flags are used by endCheck() and by the Parser to
-;; detect inconsistent return usage.
-;;
-;; END_UNREACHED is reserved for code paths that are assumed to always be
-;; able to execute (example: throw, continue)
-;;
-;; END_DROPS_OFF indicates if the statement can transfer control to the
-;; next one. Statement such as return dont. A compound statement may have
-;; some branch that drops off control to the next statement.
-;;
-;; END_RETURNS indicates that the statement can return (without arguments)
-;; END_RETURNS_VALUE indicates that the statement can return a value.
-;;
-;; A compound statement such as
-;; if (condition) {
-;;   return value;
-;; }
-;; Will be detected as (END_DROPS_OFF | END_RETURN_VALUE) by endCheck()
-
-(defconst js2-end-unreached     #x0)
-(defconst js2-end-drops-off     #x1)
-(defconst js2-end-returns       #x2)
-(defconst js2-end-returns-value #x4)
-
-;; Rhino awkwardly passes a statementLabel parameter to the
-;; statementHelper() function, the main statement parser, which
-;; is then used by quite a few of the sub-parsers.  We just make
-;; it a buffer-local variable and make sure it's cleaned up properly.
-(js2-deflocal js2-labeled-stmt nil)  ; type `js2-labeled-stmt-node'
-
-;; Similarly, Rhino passes an inForInit boolean through about half
-;; the expression parsers.  We use a dynamically-scoped variable,
-;; which makes it easier to funcall the parsers individually without
-;; worrying about whether they take the parameter or not.
-(js2-deflocal js2-in-for-init nil)
-(js2-deflocal js2-temp-name-counter 0)
-(js2-deflocal js2-parse-stmt-count 0)
-
-(defsubst js2-get-next-temp-name ()
-  (format "$%d" (cl-incf js2-temp-name-counter)))
-
-(defvar js2-parse-interruptable-p t
-  "Set this to nil to force parse to continue until finished.
-This will mostly be useful for interpreters.")
-
-(defvar js2-statements-per-pause 50
-  "Pause after this many statements to check for user input.
-If user input is pending, stop the parse and discard the tree.
-This makes for a smoother user experience for large files.
-You may have to wait a second or two before the highlighting
-and error-reporting appear, but you can always type ahead if
-you wish.  This appears to be more or less how Eclipse, IntelliJ
-and other editors work.")
-
-(js2-deflocal js2-record-comments t
-  "Instructs the scanner to record comments in `js2-scanned-comments'.")
-
-(js2-deflocal js2-scanned-comments nil
-  "List of all comments from the current parse.")
-
-(defcustom js2-mode-indent-inhibit-undo nil
-  "Non-nil to disable collection of Undo information when indenting lines.
-Some users have requested this behavior.  It's nil by default because
-other Emacs modes don't work this way."
-  :type 'boolean
-  :group 'js2-mode)
-
-(defcustom js2-mode-indent-ignore-first-tab nil
-  "If non-nil, ignore first TAB keypress if we look indented properly.
-It's fairly common for users to navigate to an already-indented line
-and press TAB for reassurance that it's been indented.  For this class
-of users, we want the first TAB press on a line to be ignored if the
-line is already indented to one of the precomputed alternatives.
-
-This behavior is only partly implemented.  If you TAB-indent a line,
-navigate to another line, and then navigate back, it fails to clear
-the last-indented variable, so it thinks you've already hit TAB once,
-and performs the indent.  A full solution would involve getting on the
-point-motion hooks for the entire buffer.  If we come across another
-use cases that requires watching point motion, I'll consider doing it.
-
-If you set this variable to nil, then the TAB key will always change
-the indentation of the current line, if more than one alternative
-indentation spot exists."
-  :type 'boolean
-  :group 'js2-mode)
-
-(defvar js2-indent-hook nil
-  "A hook for user-defined indentation rules.
-
-Functions on this hook should expect two arguments:    (LIST INDEX)
-The LIST argument is the list of computed indentation points for
-the current line.  INDEX is the list index of the indentation point
-that `js2-bounce-indent' plans to use.  If INDEX is nil, then the
-indent function is not going to change the current line indentation.
-
-If a hook function on this list returns a non-nil value, then
-`js2-bounce-indent' assumes the hook function has performed its own
-indentation, and will do nothing.  If all hook functions on the list
-return nil, then `js2-bounce-indent' will use its computed indentation
-and reindent the line.
-
-When hook functions on this hook list are called, the variable
-`js2-mode-ast' may or may not be set, depending on whether the
-parse tree is available.  If the variable is nil, you can pass a
-callback to `js2-mode-wait-for-parse', and your callback will be
-called after the new parse tree is built.  This can take some time
-in large files.")
-
-(defface js2-warning
-  `((((class color) (background light))
-     (:underline  "orange"))
-    (((class color) (background dark))
-     (:underline "orange"))
-    (t (:underline t)))
-  "Face for JavaScript warnings."
-  :group 'js2-mode)
-
-(defface js2-error
-  `((((class color) (background light))
-     (:foreground "red"))
-    (((class color) (background dark))
-     (:foreground "red"))
-    (t (:foreground "red")))
-  "Face for JavaScript errors."
-  :group 'js2-mode)
-
-(defface js2-jsdoc-tag
-  '((t :foreground "SlateGray"))
-  "Face used to highlight @whatever tags in jsdoc comments."
-  :group 'js2-mode)
-
-(defface js2-jsdoc-type
-  '((t :foreground "SteelBlue"))
-  "Face used to highlight {FooBar} types in jsdoc comments."
-  :group 'js2-mode)
-
-(defface js2-jsdoc-value
-  '((t :foreground "PeachPuff3"))
-  "Face used to highlight tag values in jsdoc comments."
-  :group 'js2-mode)
-
-(defface js2-function-param
-  '((t :foreground "SeaGreen"))
-  "Face used to highlight function parameters in javascript."
-  :group 'js2-mode)
-
-(defface js2-function-call
-  '((t :inherit default))
-  "Face used to highlight function name in calls."
-  :group 'js2-mode)
-
-(defface js2-object-property
-  '((t :inherit default))
-  "Face used to highlight named property in object literal."
-  :group 'js2-mode)
-
-(defface js2-object-property-access
-  '((t :inherit js2-object-property))
-  "Face used to highlight property access with dot on an object."
-  :group 'js2-mode)
-
-(defface js2-instance-member
-  '((t :foreground "DarkOrchid"))
-  "Face used to highlight instance variables in javascript.
-Not currently used."
-  :group 'js2-mode)
-
-(defface js2-private-member
-  '((t :foreground "PeachPuff3"))
-  "Face used to highlight calls to private methods in javascript.
-Not currently used."
-  :group 'js2-mode)
-
-(defface js2-private-function-call
-  '((t :foreground "goldenrod"))
-  "Face used to highlight calls to private functions in javascript.
-Not currently used."
-  :group 'js2-mode)
-
-(defface js2-jsdoc-html-tag-name
-  '((((class color) (min-colors 88) (background light))
-     (:foreground "rosybrown"))
-    (((class color) (min-colors 8) (background dark))
-     (:foreground "yellow"))
-    (((class color) (min-colors 8) (background light))
-     (:foreground "magenta")))
-    "Face used to highlight jsdoc html tag names"
-  :group 'js2-mode)
-
-(defface js2-jsdoc-html-tag-delimiter
-  '((((class color) (min-colors 88) (background light))
-     (:foreground "dark khaki"))
-    (((class color) (min-colors 8) (background dark))
-     (:foreground "green"))
-    (((class color) (min-colors 8) (background light))
-     (:foreground "green")))
-  "Face used to highlight brackets in jsdoc html tags."
-  :group 'js2-mode)
-
-(defface js2-external-variable
-  '((t :foreground "orange"))
-  "Face used to highlight undeclared variable identifiers.")
-
-(defcustom js2-init-hook nil
-  ;; FIXME: We don't really need this anymore.
-  "List of functions to be called after `js2-mode' or
-`js2-minor-mode' has initialized all variables, before parsing
-the buffer for the first time."
-  :type 'hook
-  :group 'js2-mode
-  :version "20130608")
-
-(defcustom js2-post-parse-callbacks nil
-  "List of callback functions invoked after parsing finishes.
-Currently, the main use for this function is to add synthetic
-declarations to `js2-recorded-identifiers', which see."
-  :type 'hook
-  :group 'js2-mode)
-
-(defcustom js2-build-imenu-callbacks nil
-  "List of functions called during Imenu index generation.
-It's a good place to add additional entries to it, using
-`js2-record-imenu-entry'."
-  :type 'hook
-  :group 'js2-mode)
-
-(defcustom js2-highlight-external-variables t
-  "Non-nil to highlight undeclared variable identifiers.
-An undeclared variable is any variable not declared with var or let
-in the current scope or any lexically enclosing scope.  If you use
-such a variable, then you are either expecting it to originate from
-another file, or you've got a potential bug."
-  :type 'boolean
-  :group 'js2-mode)
-
-(defcustom js2-warn-about-unused-function-arguments nil
-  "Non-nil to treat function arguments like declared-but-unused variables."
-  :type 'booleanp
-  :group 'js2-mode)
-
-(defcustom js2-include-jslint-globals t
-  "Non-nil to include the identifiers from JSLint global
-declaration (see http://www.jslint.com/help.html#global) in the
-buffer-local externs list.  See `js2-additional-externs' for more
-information."
-  :type 'boolean
-  :group 'js2-mode)
-
-(defcustom js2-include-jslint-declaration-externs t
-  "Non-nil to include the identifiers JSLint assumes to be there
-under certain declarations in the buffer-local externs list.  See
-`js2-additional-externs' for more information."
-  :type 'boolean
-  :group 'js2-mode)
-
-(defvar js2-mode-map
-  (let ((map (make-sparse-keymap)))
-    (define-key map [remap indent-new-comment-line] #'js2-line-break)
-    (define-key map (kbd "C-c C-e") #'js2-mode-hide-element)
-    (define-key map (kbd "C-c C-s") #'js2-mode-show-element)
-    (define-key map (kbd "C-c C-a") #'js2-mode-show-all)
-    (define-key map (kbd "C-c C-f") #'js2-mode-toggle-hide-functions)
-    (define-key map (kbd "C-c C-t") #'js2-mode-toggle-hide-comments)
-    (define-key map (kbd "C-c C-o") #'js2-mode-toggle-element)
-    (define-key map (kbd "C-c C-w") #'js2-mode-toggle-warnings-and-errors)
-    (define-key map [down-mouse-3] #'js2-down-mouse-3)
-    (define-key map [remap js-find-symbol] #'js2-jump-to-definition)
-
-    (define-key map [menu-bar javascript]
-      (cons "JavaScript" (make-sparse-keymap "JavaScript")))
-
-    (define-key map [menu-bar javascript customize-js2-mode]
-      '(menu-item "Customize js2-mode" js2-mode-customize
-                  :help "Customize the behavior of this mode"))
-
-    (define-key map [menu-bar javascript js2-force-refresh]
-      '(menu-item "Force buffer refresh" js2-mode-reset
-                  :help "Re-parse the buffer from scratch"))
-
-    (define-key map [menu-bar javascript separator-2]
-      '("--"))
-
-    (define-key map [menu-bar javascript next-error]
-      '(menu-item "Next warning or error" next-error
-                  :enabled (and js2-mode-ast
-                                (or (js2-ast-root-errors js2-mode-ast)
-                                    (js2-ast-root-warnings js2-mode-ast)))
-                  :help "Move to next warning or error"))
-
-    (define-key map [menu-bar javascript display-errors]
-      '(menu-item "Show errors and warnings" js2-mode-display-warnings-and-errors
-                  :visible (not js2-mode-show-parse-errors)
-                  :help "Turn on display of warnings and errors"))
-
-    (define-key map [menu-bar javascript hide-errors]
-      '(menu-item "Hide errors and warnings" js2-mode-hide-warnings-and-errors
-                  :visible js2-mode-show-parse-errors
-                  :help "Turn off display of warnings and errors"))
-
-    (define-key map [menu-bar javascript separator-1]
-      '("--"))
-
-    (define-key map [menu-bar javascript js2-toggle-function]
-      '(menu-item "Show/collapse element" js2-mode-toggle-element
-                  :help "Hide or show function body or comment"))
-
-    (define-key map [menu-bar javascript show-comments]
-      '(menu-item "Show block comments" js2-mode-toggle-hide-comments
-                  :visible js2-mode-comments-hidden
-                  :help "Expand all hidden block comments"))
-
-    (define-key map [menu-bar javascript hide-comments]
-      '(menu-item "Hide block comments" js2-mode-toggle-hide-comments
-                  :visible (not js2-mode-comments-hidden)
-                  :help "Show block comments as /*...*/"))
-
-    (define-key map [menu-bar javascript show-all-functions]
-      '(menu-item "Show function bodies" js2-mode-toggle-hide-functions
-                  :visible js2-mode-functions-hidden
-                  :help "Expand all hidden function bodies"))
-
-    (define-key map [menu-bar javascript hide-all-functions]
-      '(menu-item "Hide function bodies" js2-mode-toggle-hide-functions
-                  :visible (not js2-mode-functions-hidden)
-                  :help "Show {...} for all top-level function bodies"))
-
-    map)
-  "Keymap used in `js2-mode' buffers.")
-
-(defcustom js2-bounce-indent-p nil
-  "Non-nil to bind `js2-indent-bounce' and `js2-indent-bounce-backward'.
-They will augment the default indent-line behavior with cycling
-among several computed alternatives.  See the function
-`js2-bounce-indent' for details.  The above commands will be
-bound to TAB and backtab."
-  :type 'boolean
-  :group 'js2-mode
-  :set (lambda (sym value)
-         (set-default sym value)
-         (let ((map js2-mode-map))
-           (if (not value)
-               (progn
-                 (define-key map "\t" nil)
-                 (define-key map (kbd "<backtab>") nil))
-             (define-key map "\t" #'js2-indent-bounce)
-             (define-key map (kbd "<backtab>") #'js2-indent-bounce-backward)))))
-
-(defconst js2-mode-identifier-re "[[:alpha:]_$][[:alnum:]_$]*")
-
-(defvar js2-mode-//-comment-re "^\\(\\s-*\\)//.+"
-  "Matches a //-comment line.  Must be first non-whitespace on line.
-First match-group is the leading whitespace.")
-
-(defvar js2-mode-hook nil)
-
-(js2-deflocal js2-mode-ast nil "Private variable.")
-(js2-deflocal js2-mode-parse-timer nil "Private variable.")
-(js2-deflocal js2-mode-buffer-dirty-p nil "Private variable.")
-(js2-deflocal js2-mode-parsing nil "Private variable.")
-(js2-deflocal js2-mode-node-overlay nil)
-
-(defvar js2-mode-show-overlay js2-mode-dev-mode-p
-  "Debug:  Non-nil to highlight AST nodes on mouse-down.")
-
-(js2-deflocal js2-mode-fontifications nil "Private variable")
-(js2-deflocal js2-mode-deferred-properties nil "Private variable")
-(js2-deflocal js2-imenu-recorder nil "Private variable")
-(js2-deflocal js2-imenu-function-map nil "Private variable")
-
-(defvar js2-mode-verbose-parse-p js2-mode-dev-mode-p
-  "Non-nil to emit status messages during parsing.")
-
-(defvar js2-mode-change-syntax-p t
-  "Non-nil to set the syntax-table text property on certain literals.")
-
-(defvar js2-mode-functions-hidden nil "Private variable.")
-(defvar js2-mode-comments-hidden nil "Private variable.")
-
-(defvar js2-mode-syntax-table
-  (let ((table (make-syntax-table)))
-    (c-populate-syntax-table table)
-    (modify-syntax-entry ?` "\"" table)
-    table)
-  "Syntax table used in `js2-mode' buffers.")
-
-(defvar js2-mode-abbrev-table nil
-  "Abbrev table in use in `js2-mode' buffers.")
-(define-abbrev-table 'js2-mode-abbrev-table ())
-
-(defvar js2-mode-pending-parse-callbacks nil
-  "List of functions waiting to be notified that parse is finished.")
-
-(defvar js2-mode-last-indented-line -1)
-
-;;; Localizable error and warning messages
-
-;; Messages are copied from Rhino's Messages.properties.
-;; Many of the Java-specific messages have been elided.
-;; Add any js2-specific ones at the end, so we can keep
-;; this file synced with changes to Rhino's.
-
-(defvar js2-message-table
-  (make-hash-table :test 'equal :size 250)
-  "Contains localized messages for `js2-mode'.")
-
-;; TODO(stevey):  construct this table at compile-time.
-(defmacro js2-msg (key &rest strings)
-  `(puthash ,key (concat ,@strings)
-            js2-message-table))
-
-(defun js2-get-msg (msg-key)
-  "Look up a localized message.
-MSG-KEY is a list of (MSG ARGS).  If the message takes parameters,
-the correct number of ARGS must be provided."
-  (let* ((key (if (listp msg-key) (car msg-key) msg-key))
-         (args (if (listp msg-key) (cdr msg-key)))
-         (msg (gethash key js2-message-table)))
-    (if msg
-        (apply #'format msg args)
-      key)))  ; default to showing the key
-
-(js2-msg "msg.dup.parms"
-         "Duplicate parameter name '%s'.")
-
-(js2-msg "msg.too.big.jump"
-         "Program too complex: jump offset too big.")
-
-(js2-msg "msg.too.big.index"
-         "Program too complex: internal index exceeds 64K limit.")
-
-(js2-msg "msg.while.compiling.fn"
-         "Encountered code generation error while compiling function '%s': %s")
-
-(js2-msg "msg.while.compiling.script"
-         "Encountered code generation error while compiling script: %s")
-
-;; Context
-(js2-msg "msg.ctor.not.found"
-         "Constructor for '%s' not found.")
-
-(js2-msg "msg.not.ctor"
-         "'%s' is not a constructor.")
-
-;; FunctionObject
-(js2-msg "msg.varargs.ctor"
-         "Method or constructor '%s' must be static "
-         "with the signature (Context cx, Object[] args, "
-         "Function ctorObj, boolean inNewExpr) "
-         "to define a variable arguments constructor.")
-
-(js2-msg "msg.varargs.fun"
-         "Method '%s' must be static with the signature "
-         "(Context cx, Scriptable thisObj, Object[] args, Function funObj) "
-         "to define a variable arguments function.")
-
-(js2-msg "msg.incompat.call"
-         "Method '%s' called on incompatible object.")
-
-(js2-msg "msg.bad.parms"
-         "Unsupported parameter type '%s' in method '%s'.")
-
-(js2-msg "msg.bad.method.return"
-         "Unsupported return type '%s' in method '%s'.")
-
-(js2-msg "msg.bad.ctor.return"
-         "Construction of objects of type '%s' is not supported.")
-
-(js2-msg "msg.no.overload"
-         "Method '%s' occurs multiple times in class '%s'.")
-
-(js2-msg "msg.method.not.found"
-         "Method '%s' not found in '%s'.")
-
-;; IRFactory
-
-(js2-msg "msg.bad.for.in.lhs"
-         "Invalid left-hand side of for..in loop.")
-
-(js2-msg "msg.mult.index"
-         "Only one variable allowed in for..in loop.")
-
-(js2-msg "msg.bad.for.in.destruct"
-         "Left hand side of for..in loop must be an array of "
-         "length 2 to accept key/value pair.")
-
-(js2-msg "msg.cant.convert"
-         "Can't convert to type '%s'.")
-
-(js2-msg "msg.bad.assign.left"
-         "Invalid assignment left-hand side.")
-
-(js2-msg "msg.bad.decr"
-         "Invalid decrement operand.")
-
-(js2-msg "msg.bad.incr"
-         "Invalid increment operand.")
-
-(js2-msg "msg.bad.yield"
-         "yield must be in a function.")
-
-(js2-msg "msg.bad.await"
-         "await must be in async functions.")
-
-;; NativeGlobal
-(js2-msg "msg.cant.call.indirect"
-          "Function '%s' must be called directly, and not by way of a "
-          "function of another name.")
-
-(js2-msg "msg.eval.nonstring"
-          "Calling eval() with anything other than a primitive "
-          "string value will simply return the value. "
-          "Is this what you intended?")
-
-(js2-msg "msg.eval.nonstring.strict"
-         "Calling eval() with anything other than a primitive "
-         "string value is not allowed in strict mode.")
-
-(js2-msg "msg.bad.destruct.op"
-         "Invalid destructuring assignment operator")
-
-;; NativeCall
-(js2-msg "msg.only.from.new"
-         "'%s' may only be invoked from a `new' expression.")
-
-(js2-msg "msg.deprec.ctor"
-         "The '%s' constructor is deprecated.")
-
-;; NativeFunction
-(js2-msg "msg.no.function.ref.found"
-         "no source found to decompile function reference %s")
-
-(js2-msg "msg.arg.isnt.array"
-         "second argument to Function.prototype.apply must be an array")
-
-;; NativeGlobal
-(js2-msg "msg.bad.esc.mask"
-         "invalid string escape mask")
-
-;; NativeRegExp
-(js2-msg "msg.bad.quant"
-  "Invalid quantifier %s")
-
-(js2-msg "msg.overlarge.backref"
-  "Overly large back reference %s")
-
-(js2-msg "msg.overlarge.min"
-  "Overly large minimum %s")
-
-(js2-msg "msg.overlarge.max"
-  "Overly large maximum %s")
-
-(js2-msg "msg.zero.quant"
-  "Zero quantifier %s")
-
-(js2-msg "msg.max.lt.min"
-  "Maximum %s less than minimum")
-
-(js2-msg "msg.unterm.quant"
-  "Unterminated quantifier %s")
-
-(js2-msg "msg.unterm.paren"
-  "Unterminated parenthetical %s")
-
-(js2-msg "msg.unterm.class"
-  "Unterminated character class %s")
-
-(js2-msg "msg.bad.range"
-  "Invalid range in character class.")
-
-(js2-msg "msg.trail.backslash"
-  "Trailing \\ in regular expression.")
-
-(js2-msg "msg.re.unmatched.right.paren"
-  "unmatched ) in regular expression.")
-
-(js2-msg "msg.no.regexp"
-  "Regular expressions are not available.")
-
-(js2-msg "msg.bad.backref"
-  "back-reference exceeds number of capturing parentheses.")
-
-(js2-msg "msg.bad.regexp.compile"
-         "Only one argument may be specified if the first "
-         "argument to RegExp.prototype.compile is a RegExp object.")
-
-;; Parser
-(js2-msg "msg.got.syntax.errors"
-         "Compilation produced %s syntax errors.")
-
-(js2-msg "msg.var.redecl"
-         "Redeclaration of var %s.")
-
-(js2-msg "msg.const.redecl"
-         "TypeError: redeclaration of const %s.")
-
-(js2-msg "msg.let.redecl"
-         "TypeError: redeclaration of variable %s.")
-
-(js2-msg "msg.parm.redecl"
-         "TypeError: redeclaration of formal parameter %s.")
-
-(js2-msg "msg.fn.redecl"
-         "TypeError: redeclaration of function %s.")
-
-(js2-msg "msg.let.decl.not.in.block"
-         "SyntaxError: let declaration not directly within block")
-
-(js2-msg "msg.mod.import.decl.at.top.level"
-         "SyntaxError: import declarations may only appear at the top level")
-
-(js2-msg "msg.mod.as.after.reserved.word"
-         "SyntaxError: missing keyword 'as' after reserved word %s")
-
-(js2-msg "msg.mod.rc.after.import.spec.list"
-         "SyntaxError: missing '}' after module specifier list")
-
-(js2-msg "msg.mod.from.after.import.spec.set"
-         "SyntaxError: missing keyword 'from' after import specifier set")
-
-(js2-msg "msg.mod.declaration.after.import"
-         "SyntaxError: missing declaration after 'import' keyword")
-
-(js2-msg "msg.mod.spec.after.from"
-         "SyntaxError: missing module specifier after 'from' keyword")
-
-(js2-msg "msg.mod.export.decl.at.top.level"
-         "SyntaxError: export declarations may only appear at top level")
-
-(js2-msg "msg.mod.rc.after.export.spec.list"
-         "SyntaxError: missing '}' after export specifier list")
-
-;; NodeTransformer
-(js2-msg "msg.dup.label"
-         "duplicated label")
-
-(js2-msg "msg.undef.label"
-         "undefined label")
-
-(js2-msg "msg.bad.break"
-         "unlabelled break must be inside loop or switch")
-
-(js2-msg "msg.continue.outside"
-         "continue must be inside loop")
-
-(js2-msg "msg.continue.nonloop"
-         "continue can only use labels of iteration statements")
-
-(js2-msg "msg.bad.throw.eol"
-         "Line terminator is not allowed between the throw "
-         "keyword and throw expression.")
-
-(js2-msg "msg.unnamed.function.stmt" ; added by js2-mode
-         "function statement requires a name")
-
-(js2-msg "msg.no.paren.parms"
-         "missing ( before function parameters.")
-
-(js2-msg "msg.no.parm"
-         "missing formal parameter")
-
-(js2-msg "msg.no.paren.after.parms"
-         "missing ) after formal parameters")
-
-(js2-msg "msg.no.default.after.default.param" ; added by js2-mode
-         "parameter without default follows parameter with default")
-
-(js2-msg "msg.param.after.rest" ; added by js2-mode
-         "parameter after rest parameter")
-
-(js2-msg "msg.bad.arrow.args" ; added by js2-mode
-         "invalid arrow-function arguments (parentheses around the arrow-function may help)")
-
-(js2-msg "msg.no.brace.body"
-         "missing '{' before function body")
-
-(js2-msg "msg.no.brace.after.body"
-         "missing } after function body")
-
-(js2-msg "msg.no.paren.cond"
-         "missing ( before condition")
-
-(js2-msg "msg.no.paren.after.cond"
-         "missing ) after condition")
-
-(js2-msg "msg.no.semi.stmt"
-         "missing ; before statement")
-
-(js2-msg "msg.missing.semi"
-         "missing ; after statement")
-
-(js2-msg "msg.no.name.after.dot"
-         "missing name after . operator")
-
-(js2-msg "msg.no.name.after.coloncolon"
-         "missing name after :: operator")
-
-(js2-msg "msg.no.name.after.dotdot"
-         "missing name after .. operator")
-
-(js2-msg "msg.no.name.after.xmlAttr"
-         "missing name after .@")
-
-(js2-msg "msg.no.bracket.index"
-         "missing ] in index expression")
-
-(js2-msg "msg.no.paren.switch"
-         "missing ( before switch expression")
-
-(js2-msg "msg.no.paren.after.switch"
-         "missing ) after switch expression")
-
-(js2-msg "msg.no.brace.switch"
-         "missing '{' before switch body")
-
-(js2-msg "msg.bad.switch"
-         "invalid switch statement")
-
-(js2-msg "msg.no.colon.case"
-         "missing : after case expression")
-
-(js2-msg "msg.double.switch.default"
-         "double default label in the switch statement")
-
-(js2-msg "msg.no.while.do"
-         "missing while after do-loop body")
-
-(js2-msg "msg.no.paren.for"
-         "missing ( after for")
-
-(js2-msg "msg.no.semi.for"
-         "missing ; after for-loop initializer")
-
-(js2-msg "msg.no.semi.for.cond"
-         "missing ; after for-loop condition")
-
-(js2-msg "msg.in.after.for.name"
-         "missing in or of after for")
-
-(js2-msg "msg.no.paren.for.ctrl"
-         "missing ) after for-loop control")
-
-(js2-msg "msg.no.paren.with"
-         "missing ( before with-statement object")
-
-(js2-msg "msg.no.paren.after.with"
-         "missing ) after with-statement object")
-
-(js2-msg "msg.no.with.strict"
-         "with statements not allowed in strict mode")
-
-(js2-msg "msg.no.paren.after.let"
-         "missing ( after let")
-
-(js2-msg "msg.no.paren.let"
-         "missing ) after variable list")
-
-(js2-msg "msg.no.curly.let"
-         "missing } after let statement")
-
-(js2-msg "msg.bad.return"
-         "invalid return")
-
-(js2-msg "msg.no.brace.block"
-         "missing } in compound statement")
-
-(js2-msg "msg.bad.label"
-         "invalid label")
-
-(js2-msg "msg.bad.var"
-         "missing variable name")
-
-(js2-msg "msg.bad.var.init"
-         "invalid variable initialization")
-
-(js2-msg "msg.no.colon.cond"
-         "missing : in conditional expression")
-
-(js2-msg "msg.bad.optional.chaining"
-         "missing property name or [ or ( after optional chaining operator")
-
-(js2-msg "msg.no.paren.arg"
-         "missing ) after argument list")
-
-(js2-msg "msg.no.bracket.arg"
-         "missing ] after element list")
-
-(js2-msg "msg.bad.prop"
-         "invalid property id")
-
-(js2-msg "msg.no.colon.prop"
-         "missing : after property id")
-
-(js2-msg "msg.no.brace.prop"
-         "missing } after property list")
-
-(js2-msg "msg.no.paren"
-         "missing ) in parenthetical")
-
-(js2-msg "msg.reserved.id"
-         "'%s' is a reserved identifier")
-
-(js2-msg "msg.no.paren.catch"
-         "missing ( before catch-block condition")
-
-(js2-msg "msg.bad.catchcond"
-         "invalid catch block condition")
-
-(js2-msg "msg.catch.unreachable"
-         "any catch clauses following an unqualified catch are unreachable")
-
-(js2-msg "msg.no.brace.try"
-         "missing '{' before try block")
-
-(js2-msg "msg.no.brace.catchblock"
-         "missing '{' before catch-block body")
-
-(js2-msg "msg.try.no.catchfinally"
-         "'try' without 'catch' or 'finally'")
-
-(js2-msg "msg.no.return.value"
-         "function %s does not always return a value")
-
-(js2-msg "msg.anon.no.return.value"
-         "anonymous function does not always return a value")
-
-(js2-msg "msg.return.inconsistent"
-         "return statement is inconsistent with previous usage")
-
-(js2-msg "msg.generator.returns"
-         "TypeError: legacy generator function '%s' returns a value")
-
-(js2-msg "msg.anon.generator.returns"
-         "TypeError: anonymous legacy generator function returns a value")
-
-(js2-msg "msg.syntax"
-         "syntax error")
-
-(js2-msg "msg.unexpected.eof"
-         "Unexpected end of file")
-
-(js2-msg "msg.XML.bad.form"
-         "illegally formed XML syntax")
-
-(js2-msg "msg.XML.not.available"
-         "XML runtime not available")
-
-(js2-msg "msg.too.deep.parser.recursion"
-         "Too deep recursion while parsing")
-
-(js2-msg "msg.no.side.effects"
-         "Code has no side effects")
-
-(js2-msg "msg.extra.trailing.comma"
-         "Trailing comma is not supported in some browsers")
-
-(js2-msg "msg.array.trailing.comma"
-         "Trailing comma yields different behavior across browsers")
-
-(js2-msg "msg.equal.as.assign"
-         (concat "Test for equality (==) mistyped as assignment (=)?"
-                 " (parenthesize to suppress warning)"))
-
-(js2-msg "msg.var.hides.arg"
-         "Variable %s hides argument")
-
-(js2-msg "msg.destruct.assign.no.init"
-         "Missing = in destructuring declaration")
-
-(js2-msg "msg.init.no.destruct"
-         "Binding initializer not in destructuring assignment")
-
-(js2-msg "msg.no.octal.strict"
-         "Octal numbers prohibited in strict mode.")
-
-(js2-msg "msg.dup.obj.lit.prop.strict"
-         "Property '%s' already defined in this object literal.")
-
-(js2-msg "msg.dup.param.strict"
-         "Parameter '%s' already declared in this function.")
-
-(js2-msg "msg.bad.id.strict"
-         "'%s' is not a valid identifier for this use in strict mode.")
-
-;; ScriptRuntime
-(js2-msg "msg.no.properties"
-         "%s has no properties.")
-
-(js2-msg "msg.invalid.iterator"
-         "Invalid iterator value")
-
-(js2-msg "msg.iterator.primitive"
-         "__iterator__ returned a primitive value")
-
-(js2-msg "msg.assn.create.strict"
-         "Assignment to undeclared variable %s")
-
-(js2-msg "msg.undeclared.variable"  ; added by js2-mode
-         "Undeclared variable or function '%s'")
-
-(js2-msg "msg.unused.variable"  ; added by js2-mode
-         "Unused variable or function '%s'")
-
-(js2-msg "msg.uninitialized.variable"  ; added by js2-mode
-         "Variable '%s' referenced but never initialized")
-
-(js2-msg "msg.ref.undefined.prop"
-         "Reference to undefined property '%s'")
-
-(js2-msg "msg.prop.not.found"
-         "Property %s not found.")
-
-(js2-msg "msg.invalid.type"
-         "Invalid JavaScript value of type %s")
-
-(js2-msg "msg.primitive.expected"
-         "Primitive type expected (had %s instead)")
-
-(js2-msg "msg.namespace.expected"
-         "Namespace object expected to left of :: (found %s instead)")
-
-(js2-msg "msg.null.to.object"
-         "Cannot convert null to an object.")
-
-(js2-msg "msg.undef.to.object"
-         "Cannot convert undefined to an object.")
-
-(js2-msg "msg.cyclic.value"
-         "Cyclic %s value not allowed.")
-
-(js2-msg "msg.is.not.defined"
-         "'%s' is not defined.")
-
-(js2-msg "msg.undef.prop.read"
-         "Cannot read property '%s' from %s")
-
-(js2-msg "msg.undef.prop.write"
-         "Cannot set property '%s' of %s to '%s'")
-
-(js2-msg "msg.undef.prop.delete"
-         "Cannot delete property '%s' of %s")
-
-(js2-msg "msg.undef.method.call"
-         "Cannot call method '%s' of %s")
-
-(js2-msg "msg.undef.with"
-         "Cannot apply 'with' to %s")
-
-(js2-msg "msg.isnt.function"
-         "%s is not a function, it is %s.")
-
-(js2-msg "msg.isnt.function.in"
-         "Cannot call property %s in object %s. "
-         "It is not a function, it is '%s'.")
-
-(js2-msg "msg.function.not.found"
-         "Cannot find function %s.")
-
-(js2-msg "msg.function.not.found.in"
-         "Cannot find function %s in object %s.")
-
-(js2-msg "msg.isnt.xml.object"
-         "%s is not an xml object.")
-
-(js2-msg "msg.no.ref.to.get"
-         "%s is not a reference to read reference value.")
-
-(js2-msg "msg.no.ref.to.set"
-         "%s is not a reference to set reference value to %s.")
-
-(js2-msg "msg.no.ref.from.function"
-         "Function %s can not be used as the left-hand "
-         "side of assignment or as an operand of ++ or -- operator.")
-
-(js2-msg "msg.bad.default.value"
-         "Object's getDefaultValue() method returned an object.")
-
-(js2-msg "msg.instanceof.not.object"
-         "Can't use instanceof on a non-object.")
-
-(js2-msg "msg.instanceof.bad.prototype"
-         "'prototype' property of %s is not an object.")
-
-(js2-msg "msg.bad.radix"
-         "illegal radix %s.")
-
-;; ScriptableObject
-(js2-msg "msg.default.value"
-         "Cannot find default value for object.")
-
-(js2-msg "msg.zero.arg.ctor"
-         "Cannot load class '%s' which has no zero-parameter constructor.")
-
-(js2-msg "msg.ctor.multiple.parms"
-         "Can't define constructor or class %s since more than "
-         "one constructor has multiple parameters.")
-
-(js2-msg "msg.extend.scriptable"
-         "%s must extend ScriptableObject in order to define property %s.")
-
-(js2-msg "msg.bad.getter.parms"
-         "In order to define a property, getter %s must have zero "
-         "parameters or a single ScriptableObject parameter.")
-
-(js2-msg "msg.obj.getter.parms"
-         "Expected static or delegated getter %s to take "
-         "a ScriptableObject parameter.")
-
-(js2-msg "msg.getter.static"
-         "Getter and setter must both be static or neither be static.")
-
-(js2-msg "msg.setter.return"
-         "Setter must have void return type: %s")
-
-(js2-msg "msg.setter2.parms"
-         "Two-parameter setter must take a ScriptableObject as "
-         "its first parameter.")
-
-(js2-msg "msg.setter1.parms"
-         "Expected single parameter setter for %s")
-
-(js2-msg "msg.setter2.expected"
-         "Expected static or delegated setter %s to take two parameters.")
-
-(js2-msg "msg.setter.parms"
-         "Expected either one or two parameters for setter.")
-
-(js2-msg "msg.setter.bad.type"
-         "Unsupported parameter type '%s' in setter '%s'.")
-
-(js2-msg "msg.add.sealed"
-         "Cannot add a property to a sealed object: %s.")
-
-(js2-msg "msg.remove.sealed"
-         "Cannot remove a property from a sealed object: %s.")
-
-(js2-msg "msg.modify.sealed"
-         "Cannot modify a property of a sealed object: %s.")
-
-(js2-msg "msg.modify.readonly"
-         "Cannot modify readonly property: %s.")
-
-;; TokenStream
-(js2-msg "msg.missing.exponent"
-         "missing exponent")
-
-(js2-msg "msg.caught.nfe"
-         "number format error")
-
-(js2-msg "msg.unterminated.string.lit"
-         "unterminated string literal")
-
-(js2-msg "msg.unterminated.comment"
-         "unterminated comment")
-
-(js2-msg "msg.unterminated.re.lit"
-         "unterminated regular expression literal")
-
-(js2-msg "msg.invalid.re.flag"
-         "invalid flag after regular expression")
-
-(js2-msg "msg.no.re.input.for"
-         "no input for %s")
-
-(js2-msg "msg.illegal.character"
-         "illegal character")
-
-(js2-msg "msg.invalid.escape"
-         "invalid Unicode escape sequence")
-
-(js2-msg "msg.bad.namespace"
-         "not a valid default namespace statement. "
-         "Syntax is: default xml namespace = EXPRESSION;")
-
-;; TokensStream warnings
-(js2-msg "msg.bad.octal.literal"
-         "illegal octal literal digit %s; "
-         "interpreting it as a decimal digit")
-
-(js2-msg "msg.missing.hex.digits"
-         "missing hexadecimal digits after '0x'")
-
-(js2-msg "msg.missing.binary.digits"
-         "missing binary digits after '0b'")
-
-(js2-msg "msg.missing.octal.digits"
-         "missing octal digits after '0o'")
-
-(js2-msg "msg.script.is.not.constructor"
-         "Script objects are not constructors.")
-
-;; Arrays
-(js2-msg "msg.arraylength.bad"
-         "Inappropriate array length.")
-
-;; Arrays
-(js2-msg "msg.arraylength.too.big"
-         "Array length %s exceeds supported capacity limit.")
-
-;; URI
-(js2-msg "msg.bad.uri"
-         "Malformed URI sequence.")
-
-;; Number
-(js2-msg "msg.bad.precision"
-         "Precision %s out of range.")
-
-;; NativeGenerator
-(js2-msg "msg.send.newborn"
-         "Attempt to send value to newborn generator")
-
-(js2-msg "msg.already.exec.gen"
-         "Already executing generator")
-
-(js2-msg "msg.StopIteration.invalid"
-         "StopIteration may not be changed to an arbitrary object.")
-
-;; Interpreter
-(js2-msg "msg.yield.closing"
-         "Yield from closing generator")
-
-;; Classes
-(js2-msg "msg.unnamed.class.stmt" ; added by js2-mode
-         "class statement requires a name")
-
-(js2-msg "msg.class.unexpected.comma" ; added by js2-mode
-         "unexpected ',' between class properties")
-
-(js2-msg "msg.unexpected.static" ; added by js2-mode
-         "unexpected 'static'")
-
-(js2-msg "msg.missing.extends" ; added by js2-mode
-         "name is required after extends")
-
-(js2-msg "msg.no.brace.class" ; added by js2-mode
-         "missing '{' before class body")
-
-(js2-msg "msg.missing.computed.rb" ; added by js2-mode
-         "missing ']' after computed property expression")
-
-;;; Tokens Buffer
-
-(defconst js2-ti-max-lookahead 2)
-(defconst js2-ti-ntokens (1+ js2-ti-max-lookahead))
-
-(defun js2-new-token (offset)
-  (let ((token (make-js2-token (+ offset js2-ts-cursor))))
-    (setq js2-ti-tokens-cursor (mod (1+ js2-ti-tokens-cursor) js2-ti-ntokens))
-    (aset js2-ti-tokens js2-ti-tokens-cursor token)
-    token))
-
-(defsubst js2-current-token ()
-  (aref js2-ti-tokens js2-ti-tokens-cursor))
-
-(defsubst js2-current-token-string ()
-  (js2-token-string (js2-current-token)))
-
-(defsubst js2-current-token-type ()
-  (js2-token-type (js2-current-token)))
-
-(defsubst js2-current-token-beg ()
-  (js2-token-beg (js2-current-token)))
-
-(defsubst js2-current-token-end ()
-  (js2-token-end (js2-current-token)))
-
-(defun js2-current-token-len ()
-  (let ((token (js2-current-token)))
-    (- (js2-token-end token)
-       (js2-token-beg token))))
-
-(defun js2-ts-seek (state)
-  (setq js2-ts-lineno (js2-ts-state-lineno state)
-        js2-ts-cursor (js2-ts-state-cursor state)
-        js2-ti-tokens (js2-ts-state-tokens state)
-        js2-ti-tokens-cursor (js2-ts-state-tokens-cursor state)
-        js2-ti-lookahead (js2-ts-state-lookahead state)))
-
-;;; Utilities
-
-(defun js2-delete-if (predicate list)
-  "Remove all items satisfying PREDICATE in LIST."
-  (cl-loop for item in list
-           if (not (funcall predicate item))
-           collect item))
-
-(defun js2-position (element list)
-  "Find 0-indexed position of ELEMENT in LIST comparing with `eq'.
-Returns nil if element is not found in the list."
-  (let ((count 0)
-        found)
-    (while (and list (not found))
-      (if (eq element (car list))
-          (setq found t)
-        (setq count (1+ count)
-              list (cdr list))))
-    (if found count)))
-
-(defun js2-find-if (predicate list)
-  "Find first item satisfying PREDICATE in LIST."
-  (let (result)
-    (while (and list (not result))
-      (if (funcall predicate (car list))
-          (setq result (car list)))
-      (setq list (cdr list)))
-    result))
-
-(defmacro js2-time (form)
-  "Evaluate FORM, discard result, and return elapsed time in sec."
-  (declare (debug t))
-  (let ((beg (make-symbol "--js2-time-beg--")))
-    `(let ((,beg (current-time)))
-       ,form
-       (/ (truncate (* (- (float-time (current-time))
-                          (float-time ,beg))
-                       10000))
-          10000.0))))
-
-(defsubst js2-same-line (pos)
-  "Return t if POS is on the same line as current point."
-  (and (>= pos (point-at-bol))
-       (<= pos (point-at-eol))))
-
-(defun js2-code-bug ()
-  "Signal an error when we encounter an unexpected code path."
-  (error "failed assertion"))
-
-(defsubst js2-record-text-property (beg end prop value)
-  "Record a text property to set when parsing finishes."
-  (push (list beg end prop value) js2-mode-deferred-properties))
-
-;; I'd like to associate errors with nodes, but for now the
-;; easiest thing to do is get the context info from the last token.
-(defun js2-record-parse-error (msg &optional arg pos len)
-  (push (list (list msg arg)
-              (or pos (js2-current-token-beg))
-              (or len (js2-current-token-len)))
-        js2-parsed-errors))
-
-(defun js2-report-error (msg &optional msg-arg pos len)
-  "Signal a syntax error or record a parse error."
-  (if js2-recover-from-parse-errors
-      (js2-record-parse-error msg msg-arg pos len)
-      (signal 'js2-syntax-error
-              (list msg
-                    js2-ts-lineno
-                    (save-excursion
-                     (goto-char js2-ts-cursor)
-                     (current-column))
-                    js2-ts-hit-eof))))
-
-(defun js2-report-warning (msg &optional msg-arg pos len face)
-  (if js2-compiler-report-warning-as-error
-      (js2-report-error msg msg-arg pos len)
-    (push (list (list msg msg-arg)
-                (or pos (js2-current-token-beg))
-                (or len (js2-current-token-len))
-                face)
-          js2-parsed-warnings)))
-
-(defun js2-add-strict-warning (msg-id &optional msg-arg beg end)
-  (if js2-compiler-strict-mode
-      (js2-report-warning msg-id msg-arg beg
-                          (and beg end (- end beg)))))
-
-(put 'js2-syntax-error 'error-conditions
-     '(error syntax-error js2-syntax-error))
-(put 'js2-syntax-error 'error-message "Syntax error")
-
-(put 'js2-parse-error 'error-conditions
-     '(error parse-error js2-parse-error))
-(put 'js2-parse-error 'error-message "Parse error")
-
-(defmacro js2-clear-flag (flags flag)
-  `(setq ,flags (logand ,flags (lognot ,flag))))
-
-(defmacro js2-set-flag (flags flag)
-  "Logical-or FLAG into FLAGS."
-  `(setq ,flags (logior ,flags ,flag)))
-
-(defsubst js2-flag-set-p (flags flag)
-  (/= 0 (logand flags flag)))
-
-(defsubst js2-flag-not-set-p (flags flag)
-  (zerop (logand flags flag)))
-
-;;; AST struct and function definitions
-
-;; flags for ast node property 'member-type (used for e4x operators)
-(defvar js2-property-flag    #x1 "Property access: element is valid name.")
-(defvar js2-attribute-flag   #x2 "x.@y or x..@y.")
-(defvar js2-descendants-flag #x4 "x..y or x..@i.")
-
-(defsubst js2-relpos (pos anchor)
-  "Convert POS to be relative to ANCHOR.
-If POS is nil, returns nil."
-  (and pos (- pos anchor)))
-
-(defun js2-make-pad (indent)
-  (if (zerop indent)
-      ""
-    (make-string (* indent js2-basic-offset) ? )))
-
-(defun js2-visit-ast (node callback)
-  "Visit every node in ast NODE with visitor CALLBACK.
-
-CALLBACK is a function that takes two arguments:  (NODE END-P).  It is
-called twice:  once to visit the node, and again after all the node's
-children have been processed.  The END-P argument is nil on the first
-call and non-nil on the second call.  The return value of the callback
-affects the traversal:  if non-nil, the children of NODE are processed.
-If the callback returns nil, or if the node has no children, then the
-callback is called immediately with a non-nil END-P argument.
-
-The node traversal is approximately lexical-order, although there
-are currently no guarantees around this."
-  (when node
-    (let ((vfunc (get (aref node 0) 'js2-visitor)))
-      ;; visit the node
-      (when  (funcall callback node nil)
-        ;; visit the kids
-        (cond
-         ((eq vfunc 'js2-visit-none)
-          nil)                            ; don't even bother calling it
-         ;; Each AST node type has to define a `js2-visitor' function
-         ;; that takes a node and a callback, and calls `js2-visit-ast'
-         ;; on each child of the node.
-         (vfunc
-          (funcall vfunc node callback))
-         (t
-          (error "%s does not define a visitor-traversal function"
-                 (aref node 0)))))
-      ;; call the end-visit
-      (funcall callback node t))))
-
-(cl-defstruct (js2-node
-               (:constructor nil))  ; abstract
-  "Base AST node type."
-  (type -1)  ; token type
-  (pos -1)   ; start position of this AST node in parsed input
-  (len 1)    ; num characters spanned by the node
-  props      ; optional node property list (an alist)
-  parent)    ; link to parent node; null for root
-
-(defsubst js2-node-get-prop (node prop &optional default)
-  (or (cadr (assoc prop (js2-node-props node))) default))
-
-(defsubst js2-node-set-prop (node prop value)
-  (setf (js2-node-props node)
-        (cons (list prop value) (js2-node-props node))))
-
-(defun js2-fixup-starts (n nodes)
-  "Adjust the start positions of NODES to be relative to N.
-Any node in the list may be nil, for convenience."
-  (dolist (node nodes)
-    (when node
-      (setf (js2-node-pos node) (- (js2-node-pos node)
-                                   (js2-node-pos n))))))
-
-(defun js2-node-add-children (parent &rest nodes)
-  "Set parent node of NODES to PARENT, and return PARENT.
-Does nothing if we're not recording parent links.
-If any given node in NODES is nil, doesn't record that link."
-  (js2-fixup-starts parent nodes)
-  (dolist (node nodes)
-    (and node
-         (setf (js2-node-parent node) parent))))
-
-;; Non-recursive since it's called a frightening number of times.
-(defun js2-node-abs-pos (n)
-  (let ((pos (js2-node-pos n)))
-    (while (setq n (js2-node-parent n))
-      (setq pos (+ pos (js2-node-pos n))))
-    pos))
-
-(defsubst js2-node-abs-end (n)
-  "Return absolute buffer position of end of N."
-  (+ (js2-node-abs-pos n) (js2-node-len n)))
-
-(defun js2--struct-put (name key value)
-  (put name key value)
-  (put (intern (format "cl-struct-%s" name)) key value))
-
-;; It's important to make sure block nodes have a Lisp list for the
-;; child nodes, to limit printing recursion depth in an AST that
-;; otherwise consists of defstruct vectors.  Emacs will crash printing
-;; a sufficiently large vector tree.
-
-(cl-defstruct (js2-block-node
-               (:include js2-node)
-               (:constructor make-js2-block-node (&key (type js2-BLOCK)
-                                                       (pos (js2-current-token-beg))
-                                                       len
-                                                       props
-                                                       kids)))
-  "A block of statements."
-  kids)  ; a Lisp list of the child statement nodes
-
-(js2--struct-put 'js2-block-node 'js2-visitor 'js2-visit-block)
-(js2--struct-put 'js2-block-node 'js2-printer 'js2-print-block)
-
-(defun js2-visit-block (ast callback)
-  "Visit the `js2-block-node' children of AST."
-  (dolist (kid (js2-block-node-kids ast))
-    (js2-visit-ast kid callback)))
-
-(defun js2-print-block (n i)
-  (let ((pad (js2-make-pad i)))
-    (insert pad "{\n")
-    (dolist (kid (js2-block-node-kids n))
-      (js2-print-ast kid (1+ i)))
-    (insert pad "}")))
-
-(cl-defstruct (js2-scope
-               (:include js2-block-node)
-               (:constructor make-js2-scope (&key (type js2-BLOCK)
-                                                  (pos (js2-current-token-beg))
-                                                  len
-                                                  kids)))
-  ;; The symbol-table is a LinkedHashMap<String,Symbol> in Rhino.
-  ;; I don't have one of those handy, so I'll use an alist for now.
-  ;; It's as fast as an emacs hashtable for up to about 50 elements,
-  ;; and is much lighter-weight to construct (both CPU and mem).
-  ;; The keys are interned strings (symbols) for faster lookup.
-  ;; Should switch to hybrid alist/hashtable eventually.
-  symbol-table  ; an alist of (symbol . js2-symbol)
-  parent-scope  ; a `js2-scope'
-  top)          ; top-level `js2-scope' (script/function)
-
-(js2--struct-put 'js2-scope 'js2-visitor 'js2-visit-block)
-(js2--struct-put 'js2-scope 'js2-printer 'js2-print-none)
-
-(defun js2-node-get-enclosing-scope (node)
-  "Return the innermost `js2-scope' node surrounding NODE.
-Returns nil if there is no enclosing scope node."
-  (while (and (setq node (js2-node-parent node))
-              (not (js2-scope-p node))))
-  node)
-
-(defun js2-get-defining-scope (scope name &optional point)
-  "Search up scope chain from SCOPE looking for NAME, a string or symbol.
-Returns `js2-scope' in which NAME is defined, or nil if not found.
-
-If POINT is non-nil, and if the found declaration type is
-`js2-LET', also check that the declaration node is before POINT."
-  (let ((sym (if (symbolp name)
-                 name
-               (intern name)))
-        result
-        (continue t))
-    (while (and scope continue)
-      (if (or
-           (let ((entry (cdr (assq sym (js2-scope-symbol-table scope)))))
-             (and entry
-                  (or (not point)
-                      (not (eq js2-LET (js2-symbol-decl-type entry)))
-                      (>= point
-                          (js2-node-abs-pos (js2-symbol-ast-node entry))))))
-           (and (eq sym 'arguments)
-                (js2-function-node-p scope)))
-          (setq continue nil
-                result scope)
-        (setq scope (js2-scope-parent-scope scope))))
-    result))
-
-(defun js2-scope-get-symbol (scope name)
-  "Return symbol table entry for NAME in SCOPE.
-NAME can be a string or symbol.   Returns a `js2-symbol' or nil if not found."
-  (and (js2-scope-symbol-table scope)
-       (cdr (assq (if (symbolp name)
-                      name
-                    (intern name))
-                  (js2-scope-symbol-table scope)))))
-
-(defun js2-scope-put-symbol (scope name symbol)
-  "Enter SYMBOL into symbol-table for SCOPE under NAME.
-NAME can be a Lisp symbol or string.  SYMBOL is a `js2-symbol'."
-  (let* ((table (js2-scope-symbol-table scope))
-         (sym (if (symbolp name) name (intern name)))
-         (entry (assq sym table)))
-    (if entry
-        (setcdr entry symbol)
-      (push (cons sym symbol)
-            (js2-scope-symbol-table scope)))))
-
-(cl-defstruct (js2-symbol
-               (:constructor make-js2-symbol (decl-type name &optional ast-node)))
-  "A symbol table entry."
-  ;; One of js2-FUNCTION, js2-LP (for parameters), js2-VAR,
-  ;; js2-LET, or js2-CONST
-  decl-type
-  name  ; string
-  ast-node) ; a `js2-node'
-
-(cl-defstruct (js2-error-node
-               (:include js2-node)
-               (:constructor make-js2-error-node (&key (type js2-ERROR)
-                                                       (pos (js2-current-token-beg))
-                                                       len)))
-  "AST node representing a parse error.")
-
-(js2--struct-put 'js2-error-node 'js2-visitor 'js2-visit-none)
-(js2--struct-put 'js2-error-node 'js2-printer 'js2-print-none)
-
-(cl-defstruct (js2-script-node
-               (:include js2-scope)
-               (:constructor make-js2-script-node (&key (type js2-SCRIPT)
-                                                        (pos (js2-current-token-beg))
-                                                        len)))
-  functions   ; Lisp list of nested functions
-  regexps     ; Lisp list of (string . flags)
-  symbols     ; alist (every symbol gets unique index)
-  (param-count 0)
-  var-names   ; vector of string names
-  consts      ; bool-vector matching var-decls
-  (temp-number 0))  ; for generating temp variables
-
-(js2--struct-put 'js2-script-node 'js2-visitor 'js2-visit-block)
-(js2--struct-put 'js2-script-node 'js2-printer 'js2-print-script)
-
-(defun js2-print-script (node indent)
-  (dolist (kid (js2-block-node-kids node))
-    (js2-print-ast kid indent)))
-
-(cl-defstruct (js2-ast-root
-               (:include js2-script-node)
-               (:constructor make-js2-ast-root (&key (type js2-SCRIPT)
-                                                     (pos (js2-current-token-beg))
-                                                     len
-                                                     buffer)))
-  "The root node of a js2 AST."
-  buffer         ; the source buffer from which the code was parsed
-  comments       ; a Lisp list of comments, ordered by start position
-  errors         ; a Lisp list of errors found during parsing
-  warnings       ; a Lisp list of warnings found during parsing
-  node-count)    ; number of nodes in the tree, including the root
-
-(js2--struct-put 'js2-ast-root 'js2-visitor 'js2-visit-ast-root)
-(js2--struct-put 'js2-ast-root 'js2-printer 'js2-print-script)
-
-(defun js2-visit-ast-root (ast callback)
-  (dolist (kid (js2-ast-root-kids ast))
-    (js2-visit-ast kid callback))
-  (dolist (comment (js2-ast-root-comments ast))
-    (js2-visit-ast comment callback)))
-
-(cl-defstruct (js2-comment-node
-               (:include js2-node)
-               (:constructor make-js2-comment-node (&key (type js2-COMMENT)
-                                                         (pos (js2-current-token-beg))
-                                                         len
-                                                         format)))
-  format)  ; 'line, 'block, 'jsdoc or 'html
-
-(js2--struct-put 'js2-comment-node 'js2-visitor 'js2-visit-none)
-(js2--struct-put 'js2-comment-node 'js2-printer 'js2-print-comment)
-
-(defun js2-print-comment (n i)
-  ;; We really ought to link end-of-line comments to their nodes.
-  ;; Or maybe we could add a new comment type, 'endline.
-  (insert (js2-make-pad i)
-          (js2-node-string n)))
-
-(cl-defstruct (js2-expr-stmt-node
-               (:include js2-node)
-               (:constructor make-js2-expr-stmt-node (&key (type js2-EXPR_VOID)
-                                                           (pos js2-ts-cursor)
-                                                           len
-                                                           expr)))
-  "An expression statement."
-  expr)
-
-(defsubst js2-expr-stmt-node-set-has-result (node)
-  "Change NODE type to `js2-EXPR_RESULT'.  Used for code generation."
-  (setf (js2-node-type node) js2-EXPR_RESULT))
-
-(js2--struct-put 'js2-expr-stmt-node 'js2-visitor 'js2-visit-expr-stmt-node)
-(js2--struct-put 'js2-expr-stmt-node 'js2-printer 'js2-print-expr-stmt-node)
-
-(defun js2-visit-expr-stmt-node (n v)
-  (js2-visit-ast (js2-expr-stmt-node-expr n) v))
-
-(defun js2-print-expr-stmt-node (n indent)
-  (js2-print-ast (js2-expr-stmt-node-expr n) indent)
-  (insert ";\n"))
-
-(cl-defstruct (js2-loop-node
-               (:include js2-scope)
-               (:constructor nil))
-  "Abstract supertype of loop nodes."
-  body      ; a `js2-block-node'
-  lp        ; position of left-paren, nil if omitted
-  rp)       ; position of right-paren, nil if omitted
-
-(cl-defstruct (js2-do-node
-               (:include js2-loop-node)
-               (:constructor make-js2-do-node (&key (type js2-DO)
-                                                    (pos (js2-current-token-beg))
-                                                    len
-                                                    body
-                                                    condition
-                                                    while-pos
-                                                    lp
-                                                    rp)))
-  "AST node for do-loop."
-  condition  ; while (expression)
-  while-pos) ; buffer position of 'while' keyword
-
-(js2--struct-put 'js2-do-node 'js2-visitor 'js2-visit-do-node)
-(js2--struct-put 'js2-do-node 'js2-printer 'js2-print-do-node)
-
-(defun js2-visit-do-node (n v)
-  (js2-visit-ast (js2-do-node-body n) v)
-  (js2-visit-ast (js2-do-node-condition n) v))
-
-(defun js2-print-do-node (n i)
-  (let ((pad (js2-make-pad i)))
-    (insert pad "do {\n")
-    (dolist (kid (js2-block-node-kids (js2-do-node-body n)))
-      (js2-print-ast kid (1+ i)))
-    (insert pad "} while (")
-    (js2-print-ast (js2-do-node-condition n) 0)
-    (insert ");\n")))
-
-(cl-defstruct (js2-export-node
-               (:include js2-node)
-               (:constructor make-js2-export-node (&key (type js2-EXPORT)
-                                                        (pos (js2-current-token-beg))
-                                                        len
-                                                        exports-list
-                                                        from-clause
-                                                        declaration
-                                                        default)))
-  "AST node for an export statement. There are many things that can be exported,
-so many of its properties will be nil.
-"
-  exports-list ; lisp list of js2-export-binding-node to export
-  from-clause ; js2-from-clause-node for re-exporting symbols from another module
-  declaration ; js2-var-decl-node (var, let, const) or js2-class-node
-  default) ; js2-function-node or js2-assign-node
-
-(js2--struct-put 'js2-export-node 'js2-visitor 'js2-visit-export-node)
-(js2--struct-put 'js2-export-node 'js2-printer 'js2-print-export-node)
-
-(defun js2-visit-export-node (n v)
-  (let ((exports-list (js2-export-node-exports-list n))
-        (from (js2-export-node-from-clause n))
-        (declaration (js2-export-node-declaration n))
-        (default (js2-export-node-default n)))
-    (when exports-list
-      (dolist (export exports-list)
-        (js2-visit-ast export v)))
-    (when from
-      (js2-visit-ast from v))
-    (when declaration
-      (js2-visit-ast declaration v))
-    (when default
-      (js2-visit-ast default v))))
-
-(defun js2-print-export-node (n i)
-  (let ((pad (js2-make-pad i))
-        (exports-list (js2-export-node-exports-list n))
-        (from (js2-export-node-from-clause n))
-        (declaration (js2-export-node-declaration n))
-        (default (js2-export-node-default n)))
-    (insert pad "export ")
-    (cond
-     (default
-       (insert "default ")
-       (js2-print-ast default i))
-     (declaration
-       (js2-print-ast declaration i))
-     ((and exports-list from)
-      (js2-print-named-imports exports-list)
-      (insert " ")
-      (js2-print-from-clause from))
-     (from
-      (insert "* ")
-      (js2-print-from-clause from))
-     (exports-list
-      (js2-print-named-imports exports-list)))
-    (unless (or (and default (not (js2-assign-node-p default)))
-                (and declaration (or (js2-function-node-p declaration)
-                                     (js2-class-node-p declaration))))
-      (insert ";\n"))))
-
-(cl-defstruct (js2-while-node
-               (:include js2-loop-node)
-               (:constructor make-js2-while-node (&key (type js2-WHILE)
-                                                       (pos (js2-current-token-beg))
-                                                       len body
-                                                       condition lp
-                                                       rp)))
-  "AST node for while-loop."
-  condition)    ; while-condition
-
-(js2--struct-put 'js2-while-node 'js2-visitor 'js2-visit-while-node)
-(js2--struct-put 'js2-while-node 'js2-printer 'js2-print-while-node)
-
-(defun js2-visit-while-node (n v)
-  (js2-visit-ast (js2-while-node-condition n) v)
-  (js2-visit-ast (js2-while-node-body n) v))
-
-(defun js2-print-while-node (n i)
-  (let ((pad (js2-make-pad i)))
-    (insert pad "while (")
-    (js2-print-ast (js2-while-node-condition n) 0)
-    (insert ") {\n")
-    (js2-print-body (js2-while-node-body n) (1+ i))
-    (insert pad "}\n")))
-
-(cl-defstruct (js2-for-node
-               (:include js2-loop-node)
-               (:constructor make-js2-for-node (&key (type js2-FOR)
-                                                     (pos js2-ts-cursor)
-                                                     len body init
-                                                     condition
-                                                     update lp rp)))
-  "AST node for a C-style for-loop."
-  init       ; initialization expression
-  condition  ; loop condition
-  update)    ; update clause
-
-(js2--struct-put 'js2-for-node 'js2-visitor 'js2-visit-for-node)
-(js2--struct-put 'js2-for-node 'js2-printer 'js2-print-for-node)
-
-(defun js2-visit-for-node (n v)
-  (js2-visit-ast (js2-for-node-init n) v)
-  (js2-visit-ast (js2-for-node-condition n) v)
-  (js2-visit-ast (js2-for-node-update n) v)
-  (js2-visit-ast (js2-for-node-body n) v))
-
-(defun js2-print-for-node (n i)
-  (let ((pad (js2-make-pad i)))
-    (insert pad "for (")
-    (js2-print-ast (js2-for-node-init n) 0)
-    (insert "; ")
-    (js2-print-ast (js2-for-node-condition n) 0)
-    (insert "; ")
-    (js2-print-ast (js2-for-node-update n) 0)
-    (insert ") {\n")
-    (js2-print-body (js2-for-node-body n) (1+ i))
-    (insert pad "}\n")))
-
-(cl-defstruct (js2-for-in-node
-               (:include js2-loop-node)
-               (:constructor make-js2-for-in-node (&key (type js2-FOR)
-                                                        (pos js2-ts-cursor)
-                                                        len body
-                                                        iterator
-                                                        object
-                                                        in-pos
-                                                        each-pos
-                                                        foreach-p forof-p
-                                                        lp rp)))
-  "AST node for a for..in loop."
-  iterator  ; [var] foo in ...
-  object    ; object over which we're iterating
-  in-pos    ; buffer position of 'in' keyword
-  each-pos  ; buffer position of 'each' keyword, if foreach-p
-  foreach-p ; t if it's a for-each loop
-  forof-p)  ; t if it's a for-of loop
-
-(js2--struct-put 'js2-for-in-node 'js2-visitor 'js2-visit-for-in-node)
-(js2--struct-put 'js2-for-in-node 'js2-printer 'js2-print-for-in-node)
-
-(defun js2-visit-for-in-node (n v)
-  (js2-visit-ast (js2-for-in-node-iterator n) v)
-  (js2-visit-ast (js2-for-in-node-object n) v)
-  (js2-visit-ast (js2-for-in-node-body n) v))
-
-(defun js2-print-for-in-node (n i)
-  (let ((pad (js2-make-pad i))
-        (foreach (js2-for-in-node-foreach-p n))
-        (forof (js2-for-in-node-forof-p n)))
-    (insert pad "for ")
-    (if foreach
-        (insert "each "))
-    (insert "(")
-    (js2-print-ast (js2-for-in-node-iterator n) 0)
-    (insert (if forof " of " " in "))
-    (js2-print-ast (js2-for-in-node-object n) 0)
-    (insert ") {\n")
-    (js2-print-body (js2-for-in-node-body n) (1+ i))
-    (insert pad "}\n")))
-
-(cl-defstruct (js2-return-node
-               (:include js2-node)
-               (:constructor make-js2-return-node (&key (type js2-RETURN)
-                                                        (pos js2-ts-cursor)
-                                                        len
-                                                        retval)))
-  "AST node for a return statement."
-  retval)  ; expression to return, or 'undefined
-
-(js2--struct-put 'js2-return-node 'js2-visitor 'js2-visit-return-node)
-(js2--struct-put 'js2-return-node 'js2-printer 'js2-print-return-node)
-
-(defun js2-visit-return-node (n v)
-  (js2-visit-ast (js2-return-node-retval n) v))
-
-(defun js2-print-return-node (n i)
-  (insert (js2-make-pad i) "return")
-  (when (js2-return-node-retval n)
-    (insert " ")
-    (js2-print-ast (js2-return-node-retval n) 0))
-  (insert ";\n"))
-
-(cl-defstruct (js2-if-node
-               (:include js2-node)
-               (:constructor make-js2-if-node (&key (type js2-IF)
-                                                    (pos js2-ts-cursor)
-                                                    len condition
-                                                    then-part
-                                                    else-pos
-                                                    else-part lp
-                                                    rp)))
-  "AST node for an if-statement."
-  condition   ; expression
-  then-part   ; statement or block
-  else-pos    ; optional buffer position of 'else' keyword
-  else-part   ; optional statement or block
-  lp          ; position of left-paren, nil if omitted
-  rp)         ; position of right-paren, nil if omitted
-
-(js2--struct-put 'js2-if-node 'js2-visitor 'js2-visit-if-node)
-(js2--struct-put 'js2-if-node 'js2-printer 'js2-print-if-node)
-
-(defun js2-visit-if-node (n v)
-  (js2-visit-ast (js2-if-node-condition n) v)
-  (js2-visit-ast (js2-if-node-then-part n) v)
-  (js2-visit-ast (js2-if-node-else-part n) v))
-
-(defun js2-print-if-node (n i)
-  (let ((pad (js2-make-pad i))
-        (then-part (js2-if-node-then-part n))
-        (else-part (js2-if-node-else-part n)))
-    (insert pad "if (")
-    (js2-print-ast (js2-if-node-condition n) 0)
-    (insert ") {\n")
-    (js2-print-body then-part (1+ i))
-    (insert pad "}")
-    (cond
-     ((not else-part)
-      (insert "\n"))
-     ((js2-if-node-p else-part)
-      (insert " else ")
-      (js2-print-body else-part i))
-     (t
-      (insert " else {\n")
-      (js2-print-body else-part (1+ i))
-      (insert pad "}\n")))))
-
-(cl-defstruct (js2-export-binding-node
-               (:include js2-node)
-               (:constructor make-js2-export-binding-node (&key (type -1)
-                                                                pos
-                                                                len
-                                                                local-name
-                                                                extern-name)))
-  "AST node for an external symbol binding.
-It contains a local-name node which is the name of the value in the
-current scope, and extern-name which is the name of the value in the
-imported or exported scope. By default these are the same, but if the
-name is aliased as in {foo as bar}, it would have an extern-name node
-containing 'foo' and a local-name node containing 'bar'."
-  local-name ; js2-name-node with the variable name in this scope
-  extern-name)   ; js2-name-node with the value name in the exporting module
-
-(js2--struct-put 'js2-export-binding-node 'js2-printer 'js2-print-extern-binding)
-(js2--struct-put 'js2-export-binding-node 'js2-visitor 'js2-visit-extern-binding)
-
-(defun js2-visit-extern-binding (n v)
-  "Visit an extern binding node. First visit the local-name, and, if
-different, visit the extern-name."
-  (let ((local-name (js2-export-binding-node-local-name n))
-        (extern-name (js2-export-binding-node-extern-name n)))
-    (when local-name
-      (js2-visit-ast local-name v))
-    (when (not (equal local-name extern-name))
-      (js2-visit-ast extern-name v))))
-
-(defun js2-print-extern-binding (n _i)
-  "Print a representation of a single extern binding. E.g. 'foo' or
-'foo as bar'."
-  (let ((local-name (js2-export-binding-node-local-name n))
-        (extern-name (js2-export-binding-node-extern-name n)))
-    (insert (js2-name-node-name extern-name))
-    (when (not (equal local-name extern-name))
-      (insert " as ")
-      (insert (js2-name-node-name local-name)))))
-
-
-(cl-defstruct (js2-import-node
-               (:include js2-node)
-               (:constructor make-js2-import-node (&key (type js2-IMPORT)
-                                                        (pos (js2-current-token-beg))
-                                                        len
-                                                        import
-                                                        from
-                                                        module-id)))
-  "AST node for an import statement. It follows the form
-
-import ModuleSpecifier;
-import ImportClause FromClause;"
-  import     ; js2-import-clause-node specifying which names are to imported.
-  from       ; js2-from-clause-node indicating the module from which to import.
-  module-id) ; module-id of the import. E.g. 'src/mylib'.
-
-(js2--struct-put 'js2-import-node 'js2-printer 'js2-print-import)
-(js2--struct-put 'js2-import-node 'js2-visitor 'js2-visit-import)
-
-(defun js2-visit-import (n v)
-  (let ((import-clause (js2-import-node-import n))
-        (from-clause (js2-import-node-from n)))
-    (when import-clause
-      (js2-visit-ast import-clause v))
-    (when from-clause
-      (js2-visit-ast from-clause v))))
-
-(defun js2-print-import (n i)
-  "Prints a representation of the import node"
-  (let ((pad (js2-make-pad i))
-        (import-clause (js2-import-node-import n))
-        (from-clause (js2-import-node-from n))
-        (module-id (js2-import-node-module-id n)))
-    (insert pad "import ")
-    (if import-clause
-        (progn
-          (js2-print-import-clause import-clause)
-          (insert " ")
-          (js2-print-from-clause from-clause))
-      (insert "'")
-      (insert module-id)
-      (insert "'"))
-    (insert ";\n")))
-
-(cl-defstruct (js2-import-clause-node
-               (:include js2-node)
-               (:constructor make-js2-import-clause-node (&key (type -1)
-                                                               pos
-                                                               len
-                                                               namespace-import
-                                                               named-imports
-                                                               default-binding)))
-  "AST node corresponding to the import clause of an import statement. This is
-the portion of the import that bindings names from the external context to the
-local context."
-  namespace-import ; js2-namespace-import-node. E.g. '* as lib'
-  named-imports    ; lisp list of js2-export-binding-node for all named imports.
-  default-binding) ; js2-export-binding-node for the default import binding
-
-(js2--struct-put 'js2-import-clause-node 'js2-visitor 'js2-visit-import-clause)
-(js2--struct-put 'js2-import-clause-node 'js2-printer 'js2-print-import-clause)
-
-(defun js2-visit-import-clause (n v)
-  (let ((ns-import (js2-import-clause-node-namespace-import n))
-        (named-imports (js2-import-clause-node-named-imports n))
-        (default (js2-import-clause-node-default-binding n)))
-    (when default
-      (js2-visit-ast default v))
-    (when ns-import
-      (js2-visit-ast ns-import v))
-    (when named-imports
-      (dolist (import named-imports)
-        (js2-visit-ast import v)))))
-
-(defun js2-print-import-clause (n)
-  (let ((ns-import (js2-import-clause-node-namespace-import n))
-        (named-imports (js2-import-clause-node-named-imports n))
-        (default (js2-import-clause-node-default-binding n)))
-    (cond
-     ((and default ns-import)
-      (js2-print-ast default)
-      (insert ", ")
-      (js2-print-namespace-import ns-import))
-     ((and default named-imports)
-      (js2-print-ast default)
-      (insert ", ")
-      (js2-print-named-imports named-imports))
-     (default
-      (js2-print-ast default))
-     (ns-import
-      (js2-print-namespace-import ns-import))
-     (named-imports
-      (js2-print-named-imports named-imports)))))
-
-(defun js2-print-namespace-import (node)
-  (insert "* as ")
-  (insert (js2-name-node-name (js2-namespace-import-node-name node))))
-
-(defun js2-print-named-imports (imports)
-  (insert "{")
-  (let ((len (length imports))
-        (n 0))
-    (while (< n len)
-      (js2-print-extern-binding (nth n imports) 0)
-      (unless (= n (- len 1))
-        (insert ", "))
-      (setq n (+ n 1))))
-  (insert "}"))
-
-(cl-defstruct (js2-namespace-import-node
-               (:include js2-node)
-               (:constructor make-js2-namespace-import-node (&key (type -1)
-                                                                  pos
-                                                                  len
-                                                                  name)))
-  "AST node for a complete namespace import.
-E.g. the '* as lib' expression in:
-
-import * as lib from 'src/lib'
-
-It contains a single name node referring to the bound name."
-  name) ; js2-name-node of the bound name.
-
-(defun js2-visit-namespace-import (n v)
-  (js2-visit-ast (js2-namespace-import-node-name n) v))
-
-(js2--struct-put 'js2-namespace-import-node 'js2-visitor 'js2-visit-namespace-import)
-(js2--struct-put 'js2-namespace-import-node 'js2-printer 'js2-print-namespace-import)
-
-(cl-defstruct (js2-from-clause-node
-               (:include js2-node)
-               (:constructor make-js2-from-clause-node (&key (type js2-NAME)
-                                                             pos
-                                                             len
-                                                             module-id
-                                                             metadata-p)))
-  "AST node for the from clause in an import or export statement.
-E.g. from 'my/module'. It can refere to either an external module, or to the
-modules metadata itself."
-  module-id ; string containing the module specifier.
-  metadata-p) ; true if this clause refers to the module's metadata
-
-(js2--struct-put 'js2-from-clause-node 'js2-visitor 'js2-visit-none)
-(js2--struct-put 'js2-from-clause-node 'js2-printer 'js2-print-from-clause)
-
-(defun js2-print-from-clause (n)
-  (insert "from ")
-  (if (js2-from-clause-node-metadata-p n)
-      (insert "this module")
-    (insert "'")
-    (insert (js2-from-clause-node-module-id n))
-    (insert "'")))
-
-(cl-defstruct (js2-try-node
-               (:include js2-node)
-               (:constructor make-js2-try-node (&key (type js2-TRY)
-                                                     (pos js2-ts-cursor)
-                                                     len
-                                                     try-block
-                                                     catch-clauses
-                                                     finally-block)))
-  "AST node for a try-statement."
-  try-block
-  catch-clauses  ; a Lisp list of `js2-catch-node'
-  finally-block) ; a `js2-finally-node'
-
-(js2--struct-put 'js2-try-node 'js2-visitor 'js2-visit-try-node)
-(js2--struct-put 'js2-try-node 'js2-printer 'js2-print-try-node)
-
-(defun js2-visit-try-node (n v)
-  (js2-visit-ast (js2-try-node-try-block n) v)
-  (dolist (clause (js2-try-node-catch-clauses n))
-    (js2-visit-ast clause v))
-  (js2-visit-ast (js2-try-node-finally-block n) v))
-
-(defun js2-print-try-node (n i)
-  (let ((pad (js2-make-pad i))
-        (catches (js2-try-node-catch-clauses n))
-        (finally (js2-try-node-finally-block n)))
-    (insert pad "try {\n")
-    (js2-print-body (js2-try-node-try-block n) (1+ i))
-    (insert pad "}")
-    (when catches
-      (dolist (catch catches)
-        (js2-print-ast catch i)))
-    (if finally
-        (js2-print-ast finally i)
-      (insert "\n"))))
-
-(cl-defstruct (js2-catch-node
-               (:include js2-scope)
-               (:constructor make-js2-catch-node (&key (type js2-CATCH)
-                                                       (pos js2-ts-cursor)
-                                                       len
-                                                       param
-                                                       guard-kwd
-                                                       guard-expr
-                                                       lp rp)))
-  "AST node for a catch clause."
-  param       ; destructuring form or simple name node
-  guard-kwd   ; relative buffer position of "if" in "catch (x if ...)"
-  guard-expr  ; catch condition, a `js2-node'
-  lp          ; buffer position of left-paren, nil if omitted
-  rp)         ; buffer position of right-paren, nil if omitted
-
-(js2--struct-put 'js2-catch-node 'js2-visitor 'js2-visit-catch-node)
-(js2--struct-put 'js2-catch-node 'js2-printer 'js2-print-catch-node)
-
-(defun js2-visit-catch-node (n v)
-  (js2-visit-ast (js2-catch-node-param n) v)
-  (when (js2-catch-node-guard-kwd n)
-    (js2-visit-ast (js2-catch-node-guard-expr n) v))
-  (js2-visit-block n v))
-
-(defun js2-print-catch-node (n i)
-  (let ((pad (js2-make-pad i))
-        (guard-kwd (js2-catch-node-guard-kwd n))
-        (guard-expr (js2-catch-node-guard-expr n)))
-    (insert " catch (")
-    (js2-print-ast (js2-catch-node-param n) 0)
-    (when guard-kwd
-      (insert " if ")
-      (js2-print-ast guard-expr 0))
-    (insert ") {\n")
-    (js2-print-body n (1+ i))
-    (insert pad "}")))
-
-(cl-defstruct (js2-finally-node
-               (:include js2-node)
-               (:constructor make-js2-finally-node (&key (type js2-FINALLY)
-                                                         (pos js2-ts-cursor)
-                                                         len body)))
-  "AST node for a finally clause."
-  body)  ; a `js2-node', often but not always a block node
-
-(js2--struct-put 'js2-finally-node 'js2-visitor 'js2-visit-finally-node)
-(js2--struct-put 'js2-finally-node 'js2-printer 'js2-print-finally-node)
-
-(defun js2-visit-finally-node (n v)
-  (js2-visit-ast (js2-finally-node-body n) v))
-
-(defun js2-print-finally-node (n i)
-  (let ((pad (js2-make-pad i)))
-    (insert " finally {\n")
-    (js2-print-body (js2-finally-node-body n) (1+ i))
-    (insert pad "}\n")))
-
-(cl-defstruct (js2-switch-node
-               (:include js2-scope)
-               (:constructor make-js2-switch-node (&key (type js2-SWITCH)
-                                                        (pos js2-ts-cursor)
-                                                        len
-                                                        discriminant
-                                                        cases lp
-                                                        rp)))
-  "AST node for a switch statement."
-  discriminant  ; a `js2-node' (switch expression)
-  cases  ; a Lisp list of `js2-case-node'
-  lp     ; position of open-paren for discriminant, nil if omitted
-  rp)    ; position of close-paren for discriminant, nil if omitted
-
-(js2--struct-put 'js2-switch-node 'js2-visitor 'js2-visit-switch-node)
-(js2--struct-put 'js2-switch-node 'js2-printer 'js2-print-switch-node)
-
-(defun js2-visit-switch-node (n v)
-  (js2-visit-ast (js2-switch-node-discriminant n) v)
-  (dolist (c (js2-switch-node-cases n))
-    (js2-visit-ast c v)))
-
-(defun js2-print-switch-node (n i)
-  (let ((pad (js2-make-pad i))
-        (cases (js2-switch-node-cases n)))
-    (insert pad "switch (")
-    (js2-print-ast (js2-switch-node-discriminant n) 0)
-    (insert ") {\n")
-    (dolist (case cases)
-      (js2-print-ast case i))
-    (insert pad "}\n")))
-
-(cl-defstruct (js2-case-node
-               (:include js2-block-node)
-               (:constructor make-js2-case-node (&key (type js2-CASE)
-                                                      (pos js2-ts-cursor)
-                                                      len kids expr)))
-  "AST node for a case clause of a switch statement."
-  expr)   ; the case expression (nil for default)
-
-(js2--struct-put 'js2-case-node 'js2-visitor 'js2-visit-case-node)
-(js2--struct-put 'js2-case-node 'js2-printer 'js2-print-case-node)
-
-(defun js2-visit-case-node (n v)
-  (js2-visit-ast (js2-case-node-expr n) v)
-  (js2-visit-block n v))
-
-(defun js2-print-case-node (n i)
-  (let ((pad (js2-make-pad i))
-        (expr (js2-case-node-expr n)))
-    (insert pad)
-    (if (null expr)
-        (insert "default:\n")
-      (insert "case ")
-      (js2-print-ast expr 0)
-      (insert ":\n"))
-    (dolist (kid (js2-case-node-kids n))
-      (js2-print-ast kid (1+ i)))))
-
-(cl-defstruct (js2-throw-node
-               (:include js2-node)
-               (:constructor make-js2-throw-node (&key (type js2-THROW)
-                                                       (pos js2-ts-cursor)
-                                                       len expr)))
-  "AST node for a throw statement."
-  expr)   ; the expression to throw
-
-(js2--struct-put 'js2-throw-node 'js2-visitor 'js2-visit-throw-node)
-(js2--struct-put 'js2-throw-node 'js2-printer 'js2-print-throw-node)
-
-(defun js2-visit-throw-node (n v)
-  (js2-visit-ast (js2-throw-node-expr n) v))
-
-(defun js2-print-throw-node (n i)
-  (insert (js2-make-pad i) "throw ")
-  (js2-print-ast (js2-throw-node-expr n) 0)
-  (insert ";\n"))
-
-(cl-defstruct (js2-with-node
-               (:include js2-node)
-               (:constructor make-js2-with-node (&key (type js2-WITH)
-                                                      (pos js2-ts-cursor)
-                                                      len object
-                                                      body lp rp)))
-  "AST node for a with-statement."
-  object
-  body
-  lp    ; buffer position of left-paren around object, nil if omitted
-  rp)   ; buffer position of right-paren around object, nil if omitted
-
-(js2--struct-put 'js2-with-node 'js2-visitor 'js2-visit-with-node)
-(js2--struct-put 'js2-with-node 'js2-printer 'js2-print-with-node)
-
-(defun js2-visit-with-node (n v)
-  (js2-visit-ast (js2-with-node-object n) v)
-  (js2-visit-ast (js2-with-node-body n) v))
-
-(defun js2-print-with-node (n i)
-  (let ((pad (js2-make-pad i)))
-    (insert pad "with (")
-    (js2-print-ast (js2-with-node-object n) 0)
-    (insert ") {\n")
-    (js2-print-body (js2-with-node-body n) (1+ i))
-    (insert pad "}\n")))
-
-(cl-defstruct (js2-label-node
-               (:include js2-node)
-               (:constructor make-js2-label-node (&key (type js2-LABEL)
-                                                       (pos js2-ts-cursor)
-                                                       len name)))
-  "AST node for a statement label or case label."
-  name   ; a string
-  loop)  ; for validating and code-generating continue-to-label
-
-(js2--struct-put 'js2-label-node 'js2-visitor 'js2-visit-none)
-(js2--struct-put 'js2-label-node 'js2-printer 'js2-print-label)
-
-(defun js2-print-label (n i)
-  (insert (js2-make-pad i)
-          (js2-label-node-name n)
-          ":\n"))
-
-(cl-defstruct (js2-labeled-stmt-node
-               (:include js2-node)
-               ;; type needs to be in `js2-side-effecting-tokens' to avoid spurious
-               ;; no-side-effects warnings, hence js2-EXPR_RESULT.
-               (:constructor make-js2-labeled-stmt-node (&key (type js2-EXPR_RESULT)
-                                                              (pos js2-ts-cursor)
-                                                              len labels stmt)))
-  "AST node for a statement with one or more labels.
-Multiple labels for a statement are collapsed into the labels field."
-  labels  ; Lisp list of `js2-label-node'
-  stmt)   ; the statement these labels are for
-
-(js2--struct-put 'js2-labeled-stmt-node 'js2-visitor 'js2-visit-labeled-stmt)
-(js2--struct-put 'js2-labeled-stmt-node 'js2-printer 'js2-print-labeled-stmt)
-
-(defun js2-get-label-by-name (lbl-stmt name)
-  "Return a `js2-label-node' by NAME from LBL-STMT's labels list.
-Returns nil if no such label is in the list."
-  (let ((label-list (js2-labeled-stmt-node-labels lbl-stmt))
-        result)
-    (while (and label-list (not result))
-      (if (string= (js2-label-node-name (car label-list)) name)
-          (setq result (car label-list))
-        (setq label-list (cdr label-list))))
-    result))
-
-(defun js2-visit-labeled-stmt (n v)
-  (dolist (label (js2-labeled-stmt-node-labels n))
-    (js2-visit-ast label v))
-  (js2-visit-ast (js2-labeled-stmt-node-stmt n) v))
-
-(defun js2-print-labeled-stmt (n i)
-  (dolist (label (js2-labeled-stmt-node-labels n))
-    (js2-print-ast label i))
-  (js2-print-ast (js2-labeled-stmt-node-stmt n) i))
-
-(defun js2-labeled-stmt-node-contains (node label)
-  "Return t if NODE contains LABEL in its label set.
-NODE is a `js2-labels-node'.  LABEL is an identifier."
-  (cl-loop for nl in (js2-labeled-stmt-node-labels node)
-           if (string= label (js2-label-node-name nl))
-           return t
-           finally return nil))
-
-(defsubst js2-labeled-stmt-node-add-label (node label)
-  "Add a `js2-label-node' to the label set for this statement."
-  (setf (js2-labeled-stmt-node-labels node)
-        (nconc (js2-labeled-stmt-node-labels node) (list label))))
-
-(cl-defstruct (js2-jump-node
-               (:include js2-node)
-               (:constructor nil))
-  "Abstract supertype of break and continue nodes."
-  label   ; `js2-name-node' for location of label identifier, if present
-  target) ; target js2-labels-node or loop/switch statement
-
-(defun js2-visit-jump-node (n v)
-  ;; We don't visit the target, since it's a back-link.
-  (js2-visit-ast (js2-jump-node-label n) v))
-
-(cl-defstruct (js2-break-node
-               (:include js2-jump-node)
-               (:constructor make-js2-break-node (&key (type js2-BREAK)
-                                                       (pos js2-ts-cursor)
-                                                       len label target)))
-  "AST node for a break statement.
-The label field is a `js2-name-node', possibly nil, for the named label
-if provided.  E.g. in 'break foo', it represents 'foo'.  The target field
-is the target of the break - a label node or enclosing loop/switch statement.")
-
-(js2--struct-put 'js2-break-node 'js2-visitor 'js2-visit-jump-node)
-(js2--struct-put 'js2-break-node 'js2-printer 'js2-print-break-node)
-
-(defun js2-print-break-node (n i)
-  (insert (js2-make-pad i) "break")
-  (when (js2-break-node-label n)
-    (insert " ")
-    (js2-print-ast (js2-break-node-label n) 0))
-  (insert ";\n"))
-
-(cl-defstruct (js2-continue-node
-               (:include js2-jump-node)
-               (:constructor make-js2-continue-node (&key (type js2-CONTINUE)
-                                                          (pos js2-ts-cursor)
-                                                          len label target)))
-  "AST node for a continue statement.
-The label field is the user-supplied enclosing label name, a `js2-name-node'.
-It is nil if continue specifies no label.  The target field is the jump target:
-a `js2-label-node' or the innermost enclosing loop.")
-
-(js2--struct-put 'js2-continue-node 'js2-visitor 'js2-visit-jump-node)
-(js2--struct-put 'js2-continue-node 'js2-printer 'js2-print-continue-node)
-
-(defun js2-print-continue-node (n i)
-  (insert (js2-make-pad i) "continue")
-  (when (js2-continue-node-label n)
-    (insert " ")
-    (js2-print-ast (js2-continue-node-label n) 0))
-  (insert ";\n"))
-
-(cl-defstruct (js2-function-node
-               (:include js2-script-node)
-               (:constructor make-js2-function-node (&key (type js2-FUNCTION)
-                                                          (pos js2-ts-cursor)
-                                                          len
-                                                          (ftype 'FUNCTION)
-                                                          (form 'FUNCTION_STATEMENT)
-                                                          (name "")
-                                                          params rest-p
-                                                          body
-                                                          generator-type
-                                                          async
-                                                          lp rp)))
-  "AST node for a function declaration.
-The `params' field is a Lisp list of nodes.  Each node is either a simple
-`js2-name-node', or if it's a destructuring-assignment parameter, a
-`js2-array-node' or `js2-object-node'."
-  ftype            ; FUNCTION, GETTER or SETTER
-  form             ; FUNCTION_{STATEMENT|EXPRESSION|ARROW}
-  name             ; function name (a `js2-name-node', or nil if anonymous)
-  params           ; a Lisp list of destructuring forms or simple name nodes
-  rest-p           ; if t, the last parameter is rest parameter
-  body             ; a `js2-block-node' or expression node (1.8 only)
-  lp               ; position of arg-list open-paren, or nil if omitted
-  rp               ; position of arg-list close-paren, or nil if omitted
-  ignore-dynamic   ; ignore value of the dynamic-scope flag (interpreter only)
-  needs-activation ; t if we need an activation object for this frame
-  generator-type   ; STAR, LEGACY, COMPREHENSION or nil
-  async            ; t if the function is defined as `async function`
-  member-expr)     ; nonstandard Ecma extension from Rhino
-
-(js2--struct-put 'js2-function-node 'js2-visitor 'js2-visit-function-node)
-(js2--struct-put 'js2-function-node 'js2-printer 'js2-print-function-node)
-
-(defun js2-visit-function-node (n v)
-  (js2-visit-ast (js2-function-node-name n) v)
-  (dolist (p (js2-function-node-params n))
-    (js2-visit-ast p v))
-  (js2-visit-ast (js2-function-node-body n) v))
-
-(defun js2-print-function-node (n i)
-  (let* ((pad (js2-make-pad i))
-         (method (js2-node-get-prop n 'METHOD_TYPE))
-         (name (or (js2-function-node-name n)
-                   (js2-function-node-member-expr n)))
-         (params (js2-function-node-params n))
-         (arrow (eq (js2-function-node-form n) 'FUNCTION_ARROW))
-         (rest-p (js2-function-node-rest-p n))
-         (body (js2-function-node-body n))
-         (expr (not (eq (js2-function-node-form n) 'FUNCTION_STATEMENT))))
-    (unless method
-      (insert pad)
-      (when (js2-function-node-async n) (insert "async "))
-      (unless arrow (insert "function"))
-      (when (eq (js2-function-node-generator-type n) 'STAR)
-        (insert "*")))
-    (when name
-      (insert " ")
-      (js2-print-ast name 0))
-    (insert "(")
-    (cl-loop with len = (length params)
-             for param in params
-             for count from 1
-             do
-             (when (and rest-p (= count len))
-               (insert "..."))
-             (js2-print-ast param 0)
-             (when (< count len)
-               (insert ", ")))
-    (insert ") ")
-    (when arrow
-      (insert "=> "))
-    (insert "{")
-    ;; TODO:  fix this to be smarter about indenting, etc.
-    (unless expr
-      (insert "\n"))
-    (if (js2-block-node-p body)
-        (js2-print-body body (1+ i))
-      (js2-print-ast body 0))
-    (insert pad "}")
-    (unless expr
-      (insert "\n"))))
-
-(defun js2-function-name (node)
-  "Return function name for NODE, a `js2-function-node', or nil if anonymous."
-  (and (js2-function-node-name node)
-       (js2-name-node-name (js2-function-node-name node))))
-
-;; Having this be an expression node makes it more flexible.
-;; There are IDE contexts, such as indentation in a for-loop initializer,
-;; that work better if you assume it's an expression.  Whenever we have
-;; a standalone var/const declaration, we just wrap with an expr stmt.
-;; Eclipse apparently screwed this up and now has two versions, expr and stmt.
-(cl-defstruct (js2-var-decl-node
-               (:include js2-node)
-               (:constructor make-js2-var-decl-node (&key (type js2-VAR)
-                                                          (pos (js2-current-token-beg))
-                                                          len kids
-                                                          decl-type)))
-  "AST node for a variable declaration list (VAR, CONST or LET).
-The node bounds differ depending on the declaration type.  For VAR or
-CONST declarations, the bounds include the var/const keyword.  For LET
-declarations, the node begins at the position of the first child."
-  kids        ; a Lisp list of `js2-var-init-node' structs.
-  decl-type)  ; js2-VAR, js2-CONST or js2-LET
-
-(js2--struct-put 'js2-var-decl-node 'js2-visitor 'js2-visit-var-decl)
-(js2--struct-put 'js2-var-decl-node 'js2-printer 'js2-print-var-decl)
-
-(defun js2-visit-var-decl (n v)
-  (dolist (kid (js2-var-decl-node-kids n))
-    (js2-visit-ast kid v)))
-
-(defun js2-print-var-decl (n i)
-  (let ((pad (js2-make-pad i))
-        (tt (js2-var-decl-node-decl-type n)))
-    (insert pad)
-    (insert (cond
-             ((= tt js2-VAR) "var ")
-             ((= tt js2-LET) "let ")
-             ((= tt js2-CONST) "const ")
-             (t
-              (error "malformed var-decl node"))))
-    (cl-loop with kids = (js2-var-decl-node-kids n)
-             with len = (length kids)
-             for kid in kids
-             for count from 1
-             do
-             (js2-print-ast kid 0)
-             (if (< count len)
-                 (insert ", ")))))
-
-(cl-defstruct (js2-var-init-node
-               (:include js2-node)
-               (:constructor make-js2-var-init-node (&key (type js2-VAR)
-                                                          (pos js2-ts-cursor)
-                                                          len target
-                                                          initializer)))
-  "AST node for a variable declaration.
-The type field will be js2-CONST for a const decl."
-  target        ; `js2-name-node', `js2-object-node', or `js2-array-node'
-  initializer)  ; initializer expression, a `js2-node'
-
-(js2--struct-put 'js2-var-init-node 'js2-visitor 'js2-visit-var-init-node)
-(js2--struct-put 'js2-var-init-node 'js2-printer 'js2-print-var-init-node)
-
-(defun js2-visit-var-init-node (n v)
-  (js2-visit-ast (js2-var-init-node-target n) v)
-  (js2-visit-ast (js2-var-init-node-initializer n) v))
-
-(defun js2-print-var-init-node (n i)
-  (let ((pad (js2-make-pad i))
-        (name (js2-var-init-node-target n))
-        (init (js2-var-init-node-initializer n)))
-    (insert pad)
-    (js2-print-ast name 0)
-    (when init
-      (insert " = ")
-      (js2-print-ast init 0))))
-
-(cl-defstruct (js2-cond-node
-               (:include js2-node)
-               (:constructor make-js2-cond-node (&key (type js2-HOOK)
-                                                      (pos js2-ts-cursor)
-                                                      len
-                                                      test-expr
-                                                      true-expr
-                                                      false-expr
-                                                      q-pos c-pos)))
-  "AST node for the ternary operator"
-  test-expr
-  true-expr
-  false-expr
-  q-pos   ; buffer position of ?
-  c-pos)  ; buffer position of :
-
-(js2--struct-put 'js2-cond-node 'js2-visitor 'js2-visit-cond-node)
-(js2--struct-put 'js2-cond-node 'js2-printer 'js2-print-cond-node)
-
-(defun js2-visit-cond-node (n v)
-  (js2-visit-ast (js2-cond-node-test-expr n) v)
-  (js2-visit-ast (js2-cond-node-true-expr n) v)
-  (js2-visit-ast (js2-cond-node-false-expr n) v))
-
-(defun js2-print-cond-node (n i)
-  (let ((pad (js2-make-pad i)))
-    (insert pad)
-    (js2-print-ast (js2-cond-node-test-expr n) 0)
-    (insert " ? ")
-    (js2-print-ast (js2-cond-node-true-expr n) 0)
-    (insert " : ")
-    (js2-print-ast (js2-cond-node-false-expr n) 0)))
-
-(cl-defstruct (js2-infix-node
-               (:include js2-node)
-               (:constructor make-js2-infix-node (&key type
-                                                       (pos js2-ts-cursor)
-                                                       len op-pos
-                                                       left right)))
-  "Represents infix expressions.
-Includes assignment ops like `|=', and the comma operator.
-The type field inherited from `js2-node' holds the operator."
-  op-pos    ; buffer position where operator begins
-  left      ; any `js2-node'
-  right)    ; any `js2-node'
-
-(js2--struct-put 'js2-infix-node 'js2-visitor 'js2-visit-infix-node)
-(js2--struct-put 'js2-infix-node 'js2-printer 'js2-print-infix-node)
-
-(defun js2-visit-infix-node (n v)
-  (js2-visit-ast (js2-infix-node-left n) v)
-  (js2-visit-ast (js2-infix-node-right n) v))
-
-(defconst js2-operator-tokens
-  (let ((table (make-hash-table :test 'eq))
-        (tokens
-         (list (cons js2-IN "in")
-               (cons js2-TYPEOF "typeof")
-               (cons js2-INSTANCEOF "instanceof")
-               (cons js2-DELPROP "delete")
-               (cons js2-AWAIT "await")
-               (cons js2-VOID "void")
-               (cons js2-COMMA ",")
-               (cons js2-COLON ":")
-               (cons js2-OR "||")
-               (cons js2-AND "&&")
-               (cons js2-INC "++")
-               (cons js2-DEC "--")
-               (cons js2-BITOR "|")
-               (cons js2-BITXOR "^")
-               (cons js2-BITAND "&")
-               (cons js2-EQ "==")
-               (cons js2-NE "!=")
-               (cons js2-LT "<")
-               (cons js2-LE "<=")
-               (cons js2-GT ">")
-               (cons js2-GE ">=")
-               (cons js2-LSH "<<")
-               (cons js2-RSH ">>")
-               (cons js2-URSH ">>>")
-               (cons js2-ADD "+")       ; infix plus
-               (cons js2-SUB "-")       ; infix minus
-               (cons js2-MUL "*")
-               (cons js2-EXPON "**")
-               (cons js2-DIV "/")
-               (cons js2-MOD "%")
-               (cons js2-NOT "!")
-               (cons js2-BITNOT "~")
-               (cons js2-POS "+")       ; unary plus
-               (cons js2-NEG "-")       ; unary minus
-               (cons js2-TRIPLEDOT "...")
-               (cons js2-SHEQ "===")    ; shallow equality
-               (cons js2-SHNE "!==")    ; shallow inequality
-               (cons js2-ASSIGN "=")
-               (cons js2-ASSIGN_BITOR "|=")
-               (cons js2-ASSIGN_BITXOR "^=")
-               (cons js2-ASSIGN_BITAND "&=")
-               (cons js2-ASSIGN_LSH "<<=")
-               (cons js2-ASSIGN_RSH ">>=")
-               (cons js2-ASSIGN_URSH ">>>=")
-               (cons js2-ASSIGN_ADD "+=")
-               (cons js2-ASSIGN_SUB "-=")
-               (cons js2-ASSIGN_MUL "*=")
-               (cons js2-ASSIGN_EXPON "**=")
-               (cons js2-ASSIGN_DIV "/=")
-               (cons js2-ASSIGN_MOD "%="))))
-    (cl-loop for (k . v) in tokens do
-             (puthash k v table))
-    table))
-
-(defun js2-print-infix-node (n i)
-  (let* ((tt (js2-node-type n))
-         (op (gethash tt js2-operator-tokens)))
-    (unless op
-      (error "unrecognized infix operator %s" (js2-node-type n)))
-    (insert (js2-make-pad i))
-    (js2-print-ast (js2-infix-node-left n) 0)
-    (unless (= tt js2-COMMA)
-      (insert " "))
-    (insert op)
-    (insert " ")
-    (js2-print-ast (js2-infix-node-right n) 0)))
-
-(cl-defstruct (js2-assign-node
-               (:include js2-infix-node)
-               (:constructor make-js2-assign-node (&key type
-                                                        (pos js2-ts-cursor)
-                                                        len op-pos
-                                                        left right)))
-  "Represents any assignment.
-The type field holds the actual assignment operator.")
-
-(js2--struct-put 'js2-assign-node 'js2-visitor 'js2-visit-infix-node)
-(js2--struct-put 'js2-assign-node 'js2-printer 'js2-print-infix-node)
-
-(cl-defstruct (js2-unary-node
-               (:include js2-node)
-               (:constructor make-js2-unary-node (&key type ; required
-                                                       (pos js2-ts-cursor)
-                                                       len operand)))
-  "AST node type for unary operator nodes.
-The type field can be NOT, BITNOT, POS, NEG, INC, DEC,
-TYPEOF, DELPROP, TRIPLEDOT or AWAIT.  For INC or DEC, a 'postfix node
-property is added if the operator follows the operand."
-  operand)  ; a `js2-node' expression
-
-(js2--struct-put 'js2-unary-node 'js2-visitor 'js2-visit-unary-node)
-(js2--struct-put 'js2-unary-node 'js2-printer 'js2-print-unary-node)
-
-(defun js2-visit-unary-node (n v)
-  (js2-visit-ast (js2-unary-node-operand n) v))
-
-(defun js2-print-unary-node (n i)
-  (let* ((tt (js2-node-type n))
-         (op (gethash tt js2-operator-tokens))
-         (postfix (js2-node-get-prop n 'postfix)))
-    (unless op
-      (error "unrecognized unary operator %s" tt))
-    (insert (js2-make-pad i))
-    (unless postfix
-      (insert op))
-    (if (or (= tt js2-TYPEOF)
-            (= tt js2-DELPROP)
-            (= tt js2-AWAIT)
-            (= tt js2-VOID))
-        (insert " "))
-    (js2-print-ast (js2-unary-node-operand n) 0)
-    (when postfix
-      (insert op))))
-
-(cl-defstruct (js2-let-node
-               (:include js2-scope)
-               (:constructor make-js2-let-node (&key (type js2-LETEXPR)
-                                                     (pos (js2-current-token-beg))
-                                                     len vars body
-                                                     lp rp)))
-  "AST node for a let expression or a let statement.
-Note that a let declaration such as let x=6, y=7 is a `js2-var-decl-node'."
-  vars   ; a `js2-var-decl-node'
-  body   ; a `js2-node' representing the expression or body block
-  lp
-  rp)
-
-(js2--struct-put 'js2-let-node 'js2-visitor 'js2-visit-let-node)
-(js2--struct-put 'js2-let-node 'js2-printer 'js2-print-let-node)
-
-(defun js2-visit-let-node (n v)
-  (js2-visit-ast (js2-let-node-vars n) v)
-  (js2-visit-ast (js2-let-node-body n) v))
-
-(defun js2-print-let-node (n i)
-  (insert (js2-make-pad i) "let (")
-  (let ((p (point)))
-    (js2-print-ast (js2-let-node-vars n) 0)
-    (delete-region p (+ p 4)))
-  (insert ") ")
-  (js2-print-ast (js2-let-node-body n) i))
-
-(cl-defstruct (js2-keyword-node
-               (:include js2-node)
-               (:constructor make-js2-keyword-node (&key type
-                                                         (pos (js2-current-token-beg))
-                                                         (len (- js2-ts-cursor pos)))))
-  "AST node representing a literal keyword such as `null'.
-Used for `null', `this', `true', `false' and `debugger'.
-The node type is set to js2-NULL, js2-THIS, etc.")
-
-(js2--struct-put 'js2-keyword-node 'js2-visitor 'js2-visit-none)
-(js2--struct-put 'js2-keyword-node 'js2-printer 'js2-print-keyword-node)
-
-(defun js2-print-keyword-node (n i)
-  (insert (js2-make-pad i)
-          (let ((tt (js2-node-type n)))
-            (cond
-             ((= tt js2-THIS) "this")
-             ((= tt js2-SUPER) "super")
-             ((= tt js2-NULL) "null")
-             ((= tt js2-TRUE) "true")
-             ((= tt js2-FALSE) "false")
-             ((= tt js2-DEBUGGER) "debugger")
-             (t (error "Invalid keyword literal type: %d" tt))))))
-
-(defsubst js2-this-or-super-node-p (node)
-  "Return t if NODE is a `js2-literal-node' of type js2-THIS or js2-SUPER."
-  (let ((type (js2-node-type node)))
-    (or (eq type js2-THIS) (eq type js2-SUPER))))
-
-(cl-defstruct (js2-new-node
-               (:include js2-node)
-               (:constructor make-js2-new-node (&key (type js2-NEW)
-                                                     (pos (js2-current-token-beg))
-                                                     len target
-                                                     args initializer
-                                                     lp rp)))
-  "AST node for new-expression such as new Foo()."
-  target  ; an identifier or reference
-  args    ; a Lisp list of argument nodes
-  lp      ; position of left-paren, nil if omitted
-  rp      ; position of right-paren, nil if omitted
-  initializer) ; experimental Rhino syntax:  optional `js2-object-node'
-
-(js2--struct-put 'js2-new-node 'js2-visitor 'js2-visit-new-node)
-(js2--struct-put 'js2-new-node 'js2-printer 'js2-print-new-node)
-
-(defun js2-visit-new-node (n v)
-  (js2-visit-ast (js2-new-node-target n) v)
-  (dolist (arg (js2-new-node-args n))
-    (js2-visit-ast arg v))
-  (js2-visit-ast (js2-new-node-initializer n) v))
-
-(defun js2-print-new-node (n i)
-  (insert (js2-make-pad i) "new ")
-  (js2-print-ast (js2-new-node-target n))
-  (insert "(")
-  (js2-print-list (js2-new-node-args n))
-  (insert ")")
-  (when (js2-new-node-initializer n)
-    (insert " ")
-    (js2-print-ast (js2-new-node-initializer n))))
-
-(cl-defstruct (js2-name-node
-               (:include js2-node)
-               (:constructor make-js2-name-node (&key (type js2-NAME)
-                                                      (pos (js2-current-token-beg))
-                                                      (len (- js2-ts-cursor
-                                                              (js2-current-token-beg)))
-                                                      (name (js2-current-token-string)))))
-  "AST node for a JavaScript identifier"
-  name   ; a string
-  scope) ; a `js2-scope' (optional, used for codegen)
-
-(js2--struct-put 'js2-name-node 'js2-visitor 'js2-visit-none)
-(js2--struct-put 'js2-name-node 'js2-printer 'js2-print-name-node)
-
-(defun js2-print-name-node (n i)
-  (insert (js2-make-pad i)
-          (js2-name-node-name n)))
-
-(defsubst js2-name-node-length (node)
-  "Return identifier length of NODE, a `js2-name-node'.
-Returns 0 if NODE is nil or its identifier field is nil."
-  (if node
-      (length (js2-name-node-name node))
-    0))
-
-(cl-defstruct (js2-number-node
-               (:include js2-node)
-               (:constructor make-js2-number-node (&key (type js2-NUMBER)
-                                                        (pos (js2-current-token-beg))
-                                                        (len (- js2-ts-cursor
-                                                                (js2-current-token-beg)))
-                                                        (value (js2-current-token-string))
-                                                        (num-value (js2-token-number
-                                                                    (js2-current-token)))
-                                                        (num-base (js2-token-number-base
-                                                                   (js2-current-token)))
-                                                        (legacy-octal-p (js2-token-number-legacy-octal-p
-                                                                         (js2-current-token))))))
-  "AST node for a number literal."
-  value      ; the original string, e.g. "6.02e23"
-  num-value  ; the parsed number value
-  num-base  ; the number's base
-  legacy-octal-p)  ; whether the number is a legacy octal (0123 instead of 0o123)
-
-(js2--struct-put 'js2-number-node 'js2-visitor 'js2-visit-none)
-(js2--struct-put 'js2-number-node 'js2-printer 'js2-print-number-node)
-
-(defun js2-print-number-node (n i)
-  (insert (js2-make-pad i)
-          (number-to-string (js2-number-node-num-value n))))
-
-(cl-defstruct (js2-regexp-node
-               (:include js2-node)
-               (:constructor make-js2-regexp-node (&key (type js2-REGEXP)
-                                                        (pos (js2-current-token-beg))
-                                                        (len (- js2-ts-cursor
-                                                                (js2-current-token-beg)))
-                                                        value flags)))
-  "AST node for a regular expression literal."
-  value  ; the regexp string, without // delimiters
-  flags) ; a string of flags, e.g. `mi'.
-
-(js2--struct-put 'js2-regexp-node 'js2-visitor 'js2-visit-none)
-(js2--struct-put 'js2-regexp-node 'js2-printer 'js2-print-regexp)
-
-(defun js2-print-regexp (n i)
-  (insert (js2-make-pad i)
-          "/"
-          (js2-regexp-node-value n)
-          "/")
-  (if (js2-regexp-node-flags n)
-      (insert (js2-regexp-node-flags n))))
-
-(cl-defstruct (js2-string-node
-               (:include js2-node)
-               (:constructor make-js2-string-node (&key (type js2-STRING)
-                                                        (pos (js2-current-token-beg))
-                                                        (len (- js2-ts-cursor
-                                                                (js2-current-token-beg)))
-                                                        (value (js2-current-token-string)))))
-  "String literal.
-Escape characters are not evaluated; e.g. \n is 2 chars in value field.
-You can tell the quote type by looking at the first character."
-  value) ; the characters of the string, including the quotes
-
-(js2--struct-put 'js2-string-node 'js2-visitor 'js2-visit-none)
-(js2--struct-put 'js2-string-node 'js2-printer 'js2-print-string-node)
-
-(defun js2-print-string-node (n i)
-  (insert (js2-make-pad i)
-          (js2-node-string n)))
-
-(cl-defstruct (js2-template-node
-               (:include js2-node)
-               (:constructor make-js2-template-node (&key (type js2-TEMPLATE_HEAD)
-                                                          pos len kids)))
-  "Template literal."
-  kids)  ; `js2-string-node' is used for string segments, other nodes
-         ; for substitutions inside.
-
-(js2--struct-put 'js2-template-node 'js2-visitor 'js2-visit-template)
-(js2--struct-put 'js2-template-node 'js2-printer 'js2-print-template)
-
-(defun js2-visit-template (n callback)
-  (dolist (kid (js2-template-node-kids n))
-    (js2-visit-ast kid callback)))
-
-(defun js2-print-template (n i)
-  (insert (js2-make-pad i))
-  (dolist (kid (js2-template-node-kids n))
-    (if (js2-string-node-p kid)
-        (insert (js2-node-string kid))
-      (js2-print-ast kid))))
-
-(cl-defstruct (js2-tagged-template-node
-               (:include js2-node)
-               (:constructor make-js2-tagged-template-node (&key (type js2-TAGGED_TEMPLATE)
-                                                                 pos len tag template)))
-  "Tagged template literal."
-  tag       ; `js2-node' with the tag expression.
-  template) ; `js2-template-node' with the template.
-
-(js2--struct-put 'js2-tagged-template-node 'js2-visitor 'js2-visit-tagged-template)
-(js2--struct-put 'js2-tagged-template-node 'js2-printer 'js2-print-tagged-template)
-
-(defun js2-visit-tagged-template (n callback)
-  (js2-visit-ast (js2-tagged-template-node-tag n) callback)
-  (js2-visit-ast (js2-tagged-template-node-template n) callback))
-
-(defun js2-print-tagged-template (n i)
-  (insert (js2-make-pad i))
-  (js2-print-ast (js2-tagged-template-node-tag n))
-  (js2-print-ast (js2-tagged-template-node-template n)))
-
-(cl-defstruct (js2-array-node
-               (:include js2-node)
-               (:constructor make-js2-array-node (&key (type js2-ARRAYLIT)
-                                                       (pos js2-ts-cursor)
-                                                       len elems)))
-  "AST node for an array literal."
-  elems)  ; list of expressions.  [foo,,bar] yields a nil middle element.
-
-(js2--struct-put 'js2-array-node 'js2-visitor 'js2-visit-array-node)
-(js2--struct-put 'js2-array-node 'js2-printer 'js2-print-array-node)
-
-(defun js2-visit-array-node (n v)
-  (dolist (e (js2-array-node-elems n))
-    (js2-visit-ast e v)))  ; Can be nil; e.g. [a, ,b].
-
-(defun js2-print-array-node (n i)
-  (insert (js2-make-pad i) "[")
-  (let ((elems (js2-array-node-elems n)))
-    (js2-print-list elems)
-    (when (and elems (null (car (last elems))))
-      (insert ",")))
-  (insert "]"))
-
-(cl-defstruct (js2-object-node
-               (:include js2-node)
-               (:constructor make-js2-object-node (&key (type js2-OBJECTLIT)
-                                                        (pos js2-ts-cursor)
-                                                        len
-                                                        elems)))
-  "AST node for an object literal expression.
-`elems' is a list of `js2-object-prop-node'."
-  elems)
-
-(js2--struct-put 'js2-object-node 'js2-visitor 'js2-visit-object-node)
-(js2--struct-put 'js2-object-node 'js2-printer 'js2-print-object-node)
-
-(defun js2-visit-object-node (n v)
-  (dolist (e (js2-object-node-elems n))
-    (js2-visit-ast e v)))
-
-(defun js2-print-object-node (n i)
-  (insert (js2-make-pad i) "{")
-  (js2-print-list (js2-object-node-elems n))
-  (insert "}"))
-
-(cl-defstruct (js2-class-node
-               (:include js2-object-node)
-               (:constructor make-js2-class-node (&key (type js2-CLASS)
-                                                       (pos js2-ts-cursor)
-                                                       (form 'CLASS_STATEMENT)
-                                                       (name "")
-                                                       extends len elems)))
-  "AST node for an class expression.
-`elems' is a list of `js2-object-prop-node', and `extends' is an
-optional `js2-expr-node'"
-  form             ; CLASS_{STATEMENT|EXPRESSION}
-  name             ; class name (a `js2-node-name', or nil if anonymous)
-  extends          ; class heritage (a `js2-expr-node', or nil if none)
-  )
-
-(js2--struct-put 'js2-class-node 'js2-visitor 'js2-visit-class-node)
-(js2--struct-put 'js2-class-node 'js2-printer 'js2-print-class-node)
-
-(defun js2-visit-class-node (n v)
-  (js2-visit-ast (js2-class-node-name n) v)
-  (js2-visit-ast (js2-class-node-extends n) v)
-  (dolist (e (js2-class-node-elems n))
-    (js2-visit-ast e v)))
-
-(defun js2-print-class-node (n i)
-  (let* ((pad (js2-make-pad i))
-         (name (js2-class-node-name n))
-         (extends (js2-class-node-extends n))
-         (elems (js2-class-node-elems n)))
-    (insert pad "class")
-    (when name
-      (insert " ")
-      (js2-print-ast name 0))
-    (when extends
-      (insert " extends ")
-      (js2-print-ast extends))
-    (insert " {")
-    (dolist (elem elems)
-      (insert "\n")
-      (if (js2-node-get-prop elem 'STATIC)
-          (progn (insert (js2-make-pad (1+ i)) "static ")
-                 (js2-print-ast elem 0)) ;; TODO(sdh): indentation isn't quite right
-        (js2-print-ast elem (1+ i))))
-    (insert "\n" pad "}")))
-
-(cl-defstruct (js2-computed-prop-name-node
-               (:include js2-node)
-               (:constructor make-js2-computed-prop-name-node
-                             (&key
-                              (type js2-LB)
-                              expr
-                              (pos (js2-current-token-beg))
-                              (len (- js2-ts-cursor
-                                      (js2-current-token-beg))))))
-  "AST node for a `ComputedPropertyName'."
-  expr)
-
-(js2--struct-put 'js2-computed-prop-name-node 'js2-visitor 'js2-visit-computed-prop-name-node)
-(js2--struct-put 'js2-computed-prop-name-node 'js2-printer 'js2-print-computed-prop-name-node)
-
-(defun js2-visit-computed-prop-name-node (n v)
-  (js2-visit-ast (js2-computed-prop-name-node-expr n) v))
-
-(defun js2-print-computed-prop-name-node (n i)
-  (insert (js2-make-pad i) "[")
-  (js2-print-ast (js2-computed-prop-name-node-expr n) 0)
-  (insert "]"))
-
-(cl-defstruct (js2-object-prop-node
-               (:include js2-infix-node)
-               (:constructor make-js2-object-prop-node (&key (type js2-COLON)
-                                                             (pos js2-ts-cursor)
-                                                             len left
-                                                             right op-pos)))
-  "AST node for an object literal prop:value entry.
-The `left' field is the property: a name node, string node,
-number node or expression node.  The `right' field is a
-`js2-node' representing the initializer value.  If the property
-is abbreviated, the node's `SHORTHAND' property is non-nil and
-both fields have the same value.")
-
-(js2--struct-put 'js2-object-prop-node 'js2-visitor 'js2-visit-infix-node)
-(js2--struct-put 'js2-object-prop-node 'js2-printer 'js2-print-object-prop-node)
-
-(defun js2-print-object-prop-node (n i)
-  (let* ((left (js2-object-prop-node-left n))
-         (right (js2-object-prop-node-right n)))
-    (js2-print-ast left i)
-    (if (not (js2-node-get-prop n 'SHORTHAND))
-        (progn
-          (insert ": ")
-          (js2-print-ast right 0)))))
-
-(cl-defstruct (js2-method-node
-               (:include js2-infix-node)
-               (:constructor make-js2-method-node (&key (pos js2-ts-cursor)
-                                                        len left right)))
-  "AST node for a method in an object literal or a class body.
-The `left' field is the `js2-name-node' naming the method.
-The `right' field is always an anonymous `js2-function-node' with a node
-property `METHOD_TYPE' set to 'GET or 'SET. ")
-
-(js2--struct-put 'js2-method-node 'js2-visitor 'js2-visit-infix-node)
-(js2--struct-put 'js2-method-node 'js2-printer 'js2-print-method)
-
-(defun js2-print-method (n i)
-  (let* ((pad (js2-make-pad i))
-         (left (js2-method-node-left n))
-         (right (js2-method-node-right n))
-         (type (js2-node-get-prop right 'METHOD_TYPE)))
-    (insert pad)
-    (when type
-      (insert (cdr (assoc type '((GET . "get ")
-                                 (SET . "set ")
-                                 (ASYNC . "async ")
-                                 (FUNCTION . ""))))))
-    (when (and (js2-function-node-p right)
-               (eq 'STAR (js2-function-node-generator-type right)))
-      (insert "*"))
-    (js2-print-ast left 0)
-    (js2-print-ast right 0)))
-
-(cl-defstruct (js2-prop-get-node
-               (:include js2-infix-node)
-               (:constructor make-js2-prop-get-node (&key (type js2-GETPROP)
-                                                          (pos js2-ts-cursor)
-                                                          len left right)))
-  "AST node for a dotted property reference, e.g. foo.bar or foo().bar")
-
-(js2--struct-put 'js2-prop-get-node 'js2-visitor 'js2-visit-prop-get-node)
-(js2--struct-put 'js2-prop-get-node 'js2-printer 'js2-print-prop-get-node)
-
-(defun js2-visit-prop-get-node (n v)
-  (js2-visit-ast (js2-prop-get-node-left n) v)
-  (js2-visit-ast (js2-prop-get-node-right n) v))
-
-(defun js2-print-prop-get-node (n i)
-  (insert (js2-make-pad i))
-  (js2-print-ast (js2-prop-get-node-left n) 0)
-  (insert ".")
-  (js2-print-ast (js2-prop-get-node-right n) 0))
-
-(cl-defstruct (js2-elem-get-node
-               (:include js2-node)
-               (:constructor make-js2-elem-get-node (&key (type js2-GETELEM)
-                                                          (pos js2-ts-cursor)
-                                                          len target element
-                                                          lb rb)))
-  "AST node for an array index expression such as foo[bar]."
-  target  ; a `js2-node' - the expression preceding the "."
-  element ; a `js2-node' - the expression in brackets
-  lb      ; position of left-bracket, nil if omitted
-  rb)     ; position of right-bracket, nil if omitted
-
-(js2--struct-put 'js2-elem-get-node 'js2-visitor 'js2-visit-elem-get-node)
-(js2--struct-put 'js2-elem-get-node 'js2-printer 'js2-print-elem-get-node)
-
-(defun js2-visit-elem-get-node (n v)
-  (js2-visit-ast (js2-elem-get-node-target n) v)
-  (js2-visit-ast (js2-elem-get-node-element n) v))
-
-(defun js2-print-elem-get-node (n i)
-  (insert (js2-make-pad i))
-  (js2-print-ast (js2-elem-get-node-target n) 0)
-  (insert "[")
-  (js2-print-ast (js2-elem-get-node-element n) 0)
-  (insert "]"))
-
-(cl-defstruct (js2-call-node
-               (:include js2-node)
-               (:constructor make-js2-call-node (&key (type js2-CALL)
-                                                      (pos js2-ts-cursor)
-                                                      len target args
-                                                      lp rp)))
-  "AST node for a JavaScript function call."
-  target  ; a `js2-node' evaluating to the function to call
-  args  ; a Lisp list of `js2-node' arguments
-  lp    ; position of open-paren, or nil if missing
-  rp)   ; position of close-paren, or nil if missing
-
-(js2--struct-put 'js2-call-node 'js2-visitor 'js2-visit-call-node)
-(js2--struct-put 'js2-call-node 'js2-printer 'js2-print-call-node)
-
-(defun js2-visit-call-node (n v)
-  (js2-visit-ast (js2-call-node-target n) v)
-  (dolist (arg (js2-call-node-args n))
-    (js2-visit-ast arg v)))
-
-(defun js2-print-call-node (n i)
-  (insert (js2-make-pad i))
-  (js2-print-ast (js2-call-node-target n) 0)
-  (insert "(")
-  (js2-print-list (js2-call-node-args n))
-  (insert ")"))
-
-(cl-defstruct (js2-yield-node
-               (:include js2-node)
-               (:constructor make-js2-yield-node (&key (type js2-YIELD)
-                                                       (pos js2-ts-cursor)
-                                                       len value star-p)))
-  "AST node for yield statement or expression."
-  star-p ; whether it's yield*
-  value) ; optional:  value to be yielded
-
-(js2--struct-put 'js2-yield-node 'js2-visitor 'js2-visit-yield-node)
-(js2--struct-put 'js2-yield-node 'js2-printer 'js2-print-yield-node)
-
-(defun js2-visit-yield-node (n v)
-  (js2-visit-ast (js2-yield-node-value n) v))
-
-(defun js2-print-yield-node (n i)
-  (insert (js2-make-pad i))
-  (insert "yield")
-  (when (js2-yield-node-star-p n)
-    (insert "*"))
-  (when (js2-yield-node-value n)
-    (insert " ")
-    (js2-print-ast (js2-yield-node-value n) 0)))
-
-(cl-defstruct (js2-paren-node
-               (:include js2-node)
-               (:constructor make-js2-paren-node (&key (type js2-LP)
-                                                       (pos js2-ts-cursor)
-                                                       len expr)))
-  "AST node for a parenthesized expression.
-In particular, used when the parens are syntactically optional,
-as opposed to required parens such as those enclosing an if-conditional."
-  expr)   ; `js2-node'
-
-(js2--struct-put 'js2-paren-node 'js2-visitor 'js2-visit-paren-node)
-(js2--struct-put 'js2-paren-node 'js2-printer 'js2-print-paren-node)
-
-(defun js2-visit-paren-node (n v)
-  (js2-visit-ast (js2-paren-node-expr n) v))
-
-(defun js2-print-paren-node (n i)
-  (insert (js2-make-pad i))
-  (insert "(")
-  (js2-print-ast (js2-paren-node-expr n) 0)
-  (insert ")"))
-
-(cl-defstruct (js2-comp-node
-               (:include js2-scope)
-               (:constructor make-js2-comp-node (&key (type js2-ARRAYCOMP)
-                                                      (pos js2-ts-cursor)
-                                                      len result
-                                                      loops filters
-                                                      form)))
-  "AST node for an Array comprehension such as [[x,y] for (x in foo) for (y in bar)]."
-  result  ; result expression (just after left-bracket)
-  loops   ; a Lisp list of `js2-comp-loop-node'
-  filters ; a Lisp list of guard/filter expressions
-  form    ; ARRAY, LEGACY_ARRAY or STAR_GENERATOR
-          ; SpiderMonkey also supports "legacy generator expressions", but we dont.
-  )
-
-(js2--struct-put 'js2-comp-node 'js2-visitor 'js2-visit-comp-node)
-(js2--struct-put 'js2-comp-node 'js2-printer 'js2-print-comp-node)
-
-(defun js2-visit-comp-node (n v)
-  (js2-visit-ast (js2-comp-node-result n) v)
-  (dolist (l (js2-comp-node-loops n))
-    (js2-visit-ast l v))
-  (dolist (f (js2-comp-node-filters n))
-    (js2-visit-ast f v)))
-
-(defun js2-print-comp-node (n i)
-  (let ((pad (js2-make-pad i))
-        (result (js2-comp-node-result n))
-        (loops (js2-comp-node-loops n))
-        (filters (js2-comp-node-filters n))
-        (legacy-p (eq (js2-comp-node-form n) 'LEGACY_ARRAY))
-        (gen-p (eq (js2-comp-node-form n) 'STAR_GENERATOR)))
-    (insert pad (if gen-p "(" "["))
-    (when legacy-p
-      (js2-print-ast result 0))
-    (dolist (l loops)
-      (when legacy-p
-        (insert " "))
-      (js2-print-ast l 0)
-      (unless legacy-p
-        (insert " ")))
-    (dolist (f filters)
-      (when legacy-p
-        (insert " "))
-      (insert "if (")
-      (js2-print-ast f 0)
-      (insert ")")
-      (unless legacy-p
-        (insert " ")))
-    (unless legacy-p
-      (js2-print-ast result 0))
-    (insert (if gen-p ")" "]"))))
-
-(cl-defstruct (js2-comp-loop-node
-               (:include js2-for-in-node)
-               (:constructor make-js2-comp-loop-node (&key (type js2-FOR)
-                                                           (pos js2-ts-cursor)
-                                                           len iterator
-                                                           object in-pos
-                                                           foreach-p
-                                                           each-pos
-                                                           forof-p
-                                                           lp rp)))
-  "AST subtree for each 'for (foo in bar)' loop in an array comprehension.")
-
-(js2--struct-put 'js2-comp-loop-node 'js2-visitor 'js2-visit-comp-loop)
-(js2--struct-put 'js2-comp-loop-node 'js2-printer 'js2-print-comp-loop)
-
-(defun js2-visit-comp-loop (n v)
-  (js2-visit-ast (js2-comp-loop-node-iterator n) v)
-  (js2-visit-ast (js2-comp-loop-node-object n) v))
-
-(defun js2-print-comp-loop (n _i)
-  (insert "for ")
-  (when (js2-comp-loop-node-foreach-p n) (insert "each "))
-  (insert "(")
-  (js2-print-ast (js2-comp-loop-node-iterator n) 0)
-  (insert (if (js2-comp-loop-node-forof-p n)
-              " of " " in "))
-  (js2-print-ast (js2-comp-loop-node-object n) 0)
-  (insert ")"))
-
-(cl-defstruct (js2-empty-expr-node
-               (:include js2-node)
-               (:constructor make-js2-empty-expr-node (&key (type js2-EMPTY)
-                                                            (pos (js2-current-token-beg))
-                                                            len)))
-  "AST node for an empty expression.")
-
-(js2--struct-put 'js2-empty-expr-node 'js2-visitor 'js2-visit-none)
-(js2--struct-put 'js2-empty-expr-node 'js2-printer 'js2-print-none)
-
-(cl-defstruct (js2-xml-node
-               (:include js2-block-node)
-               (:constructor make-js2-xml-node (&key (type js2-XML)
-                                                     (pos (js2-current-token-beg))
-                                                     len kids)))
-  "AST node for initial parse of E4X literals.
-The kids field is a list of XML fragments, each a `js2-string-node' or
-a `js2-xml-js-expr-node'.  Equivalent to Rhino's XmlLiteral node.")
-
-(js2--struct-put 'js2-xml-node 'js2-visitor 'js2-visit-block)
-(js2--struct-put 'js2-xml-node 'js2-printer 'js2-print-xml-node)
-
-(defun js2-print-xml-node (n i)
-  (dolist (kid (js2-xml-node-kids n))
-    (js2-print-ast kid i)))
-
-(cl-defstruct (js2-xml-js-expr-node
-               (:include js2-xml-node)
-               (:constructor make-js2-xml-js-expr-node (&key (type js2-XML)
-                                                             (pos js2-ts-cursor)
-                                                             len expr)))
-  "AST node for an embedded JavaScript {expression} in an E4X literal.
-The start and end fields correspond to the curly-braces."
-  expr)  ; a `js2-expr-node' of some sort
-
-(js2--struct-put 'js2-xml-js-expr-node 'js2-visitor 'js2-visit-xml-js-expr)
-(js2--struct-put 'js2-xml-js-expr-node 'js2-printer 'js2-print-xml-js-expr)
-
-(defun js2-visit-xml-js-expr (n v)
-  (js2-visit-ast (js2-xml-js-expr-node-expr n) v))
-
-(defun js2-print-xml-js-expr (n i)
-  (insert (js2-make-pad i))
-  (insert "{")
-  (js2-print-ast (js2-xml-js-expr-node-expr n) 0)
-  (insert "}"))
-
-(cl-defstruct (js2-xml-dot-query-node
-               (:include js2-infix-node)
-               (:constructor make-js2-xml-dot-query-node (&key (type js2-DOTQUERY)
-                                                               (pos js2-ts-cursor)
-                                                               op-pos len left
-                                                               right rp)))
-  "AST node for an E4X foo.(bar) filter expression.
-Note that the left-paren is automatically the character immediately
-following the dot (.) in the operator.  No whitespace is permitted
-between the dot and the lp by the scanner."
-  rp)
-
-(js2--struct-put 'js2-xml-dot-query-node 'js2-visitor 'js2-visit-infix-node)
-(js2--struct-put 'js2-xml-dot-query-node 'js2-printer 'js2-print-xml-dot-query)
-
-(defun js2-print-xml-dot-query (n i)
-  (insert (js2-make-pad i))
-  (js2-print-ast (js2-xml-dot-query-node-left n) 0)
-  (insert ".(")
-  (js2-print-ast (js2-xml-dot-query-node-right n) 0)
-  (insert ")"))
-
-(cl-defstruct (js2-xml-ref-node
-               (:include js2-node)
-               (:constructor nil))  ; abstract
-  "Base type for E4X XML attribute-access or property-get expressions.
-Such expressions can take a variety of forms.  The general syntax has
-three parts:
-
-  - (optional) an @ (specifying an attribute access)
-  - (optional) a namespace (a `js2-name-node') and double-colon
-  - (required) either a `js2-name-node' or a bracketed [expression]
-
-The property-name expressions (examples:  ns::name, @name) are
-represented as `js2-xml-prop-ref' nodes.  The bracketed-expression
-versions (examples:  ns::[name], @[name]) become `js2-xml-elem-ref' nodes.
-
-This node type (or more specifically, its subclasses) will sometimes
-be the right-hand child of a `js2-prop-get-node' or a
-`js2-infix-node' of type `js2-DOTDOT', the .. xml-descendants operator.
-The `js2-xml-ref-node' may also be a standalone primary expression with
-no explicit target, which is valid in certain expression contexts such as
-
-  company..employee.(@id < 100)
-
-in this case, the @id is a `js2-xml-ref' that is part of an infix '<'
-expression whose parent is a `js2-xml-dot-query-node'."
-  namespace
-  at-pos
-  colon-pos)
-
-(defsubst js2-xml-ref-node-attr-access-p (node)
-  "Return non-nil if this expression began with an @-token."
-  (and (numberp (js2-xml-ref-node-at-pos node))
-       (cl-plusp (js2-xml-ref-node-at-pos node))))
-
-(cl-defstruct (js2-xml-prop-ref-node
-               (:include js2-xml-ref-node)
-               (:constructor make-js2-xml-prop-ref-node (&key (type js2-REF_NAME)
-                                                              (pos (js2-current-token-beg))
-                                                              len propname
-                                                              namespace at-pos
-                                                              colon-pos)))
-  "AST node for an E4X XML [expr] property-ref expression.
-The JavaScript syntax is an optional @, an optional ns::, and a name.
-
-  [ '@' ] [ name '::' ] name
-
-Examples include name, ns::name, ns::*, *::name, *::*, @attr, @ns::attr,
-@ns::*, @*::attr, @*::*, and @*.
-
-The node starts at the @ token, if present.  Otherwise it starts at the
-namespace name.  The node bounds extend through the closing right-bracket,
-or if it is missing due to a syntax error, through the end of the index
-expression."
-  propname)
-
-(js2--struct-put 'js2-xml-prop-ref-node 'js2-visitor 'js2-visit-xml-prop-ref-node)
-(js2--struct-put 'js2-xml-prop-ref-node 'js2-printer 'js2-print-xml-prop-ref-node)
-
-(defun js2-visit-xml-prop-ref-node (n v)
-  (js2-visit-ast (js2-xml-prop-ref-node-namespace n) v)
-  (js2-visit-ast (js2-xml-prop-ref-node-propname n) v))
-
-(defun js2-print-xml-prop-ref-node (n i)
-  (insert (js2-make-pad i))
-  (if (js2-xml-ref-node-attr-access-p n)
-      (insert "@"))
-  (when (js2-xml-prop-ref-node-namespace n)
-    (js2-print-ast (js2-xml-prop-ref-node-namespace n) 0)
-    (insert "::"))
-  (if (js2-xml-prop-ref-node-propname n)
-      (js2-print-ast (js2-xml-prop-ref-node-propname n) 0)))
-
-(cl-defstruct (js2-xml-elem-ref-node
-               (:include js2-xml-ref-node)
-               (:constructor make-js2-xml-elem-ref-node (&key (type js2-REF_MEMBER)
-                                                              (pos (js2-current-token-beg))
-                                                              len expr lb rb
-                                                              namespace at-pos
-                                                              colon-pos)))
-  "AST node for an E4X XML [expr] member-ref expression.
-Syntax:
-
- [ '@' ] [ name '::' ] '[' expr ']'
-
-Examples include ns::[expr], @ns::[expr], @[expr], *::[expr] and @*::[expr].
-
-Note that the form [expr] (i.e. no namespace or attribute-qualifier)
-is not a legal E4X XML element-ref expression, since it's already used
-for standard JavaScript element-get array indexing.  Hence, a
-`js2-xml-elem-ref-node' always has either the attribute-qualifier, a
-non-nil namespace node, or both.
-
-The node starts at the @ token, if present.  Otherwise it starts
-at the namespace name.  The node bounds extend through the closing
-right-bracket, or if it is missing due to a syntax error, through the
-end of the index expression."
-  expr  ; the bracketed index expression
-  lb
-  rb)
-
-(js2--struct-put 'js2-xml-elem-ref-node 'js2-visitor 'js2-visit-xml-elem-ref-node)
-(js2--struct-put 'js2-xml-elem-ref-node 'js2-printer 'js2-print-xml-elem-ref-node)
-
-(defun js2-visit-xml-elem-ref-node (n v)
-  (js2-visit-ast (js2-xml-elem-ref-node-namespace n) v)
-  (js2-visit-ast (js2-xml-elem-ref-node-expr n) v))
-
-(defun js2-print-xml-elem-ref-node (n i)
-  (insert (js2-make-pad i))
-  (if (js2-xml-ref-node-attr-access-p n)
-      (insert "@"))
-  (when (js2-xml-elem-ref-node-namespace n)
-    (js2-print-ast (js2-xml-elem-ref-node-namespace n) 0)
-    (insert "::"))
-  (insert "[")
-  (if (js2-xml-elem-ref-node-expr n)
-      (js2-print-ast (js2-xml-elem-ref-node-expr n) 0))
-  (insert "]"))
-
-;;; Placeholder nodes for when we try parsing the XML literals structurally.
-
-(cl-defstruct (js2-xml-start-tag-node
-               (:include js2-xml-node)
-               (:constructor make-js2-xml-start-tag-node (&key (type js2-XML)
-                                                               (pos js2-ts-cursor)
-                                                               len name attrs kids
-                                                               empty-p)))
-  "AST node for an XML start-tag.  Not currently used.
-The `kids' field is a Lisp list of child content nodes."
-  name      ; a `js2-xml-name-node'
-  attrs     ; a Lisp list of `js2-xml-attr-node'
-  empty-p)  ; t if this is an empty element such as <foo bar="baz"/>
-
-(js2--struct-put 'js2-xml-start-tag-node 'js2-visitor 'js2-visit-xml-start-tag)
-(js2--struct-put 'js2-xml-start-tag-node 'js2-printer 'js2-print-xml-start-tag)
-
-(defun js2-visit-xml-start-tag (n v)
-  (js2-visit-ast (js2-xml-start-tag-node-name n) v)
-  (dolist (attr (js2-xml-start-tag-node-attrs n))
-    (js2-visit-ast attr v))
-  (js2-visit-block n v))
-
-(defun js2-print-xml-start-tag (n i)
-  (insert (js2-make-pad i) "<")
-  (js2-print-ast (js2-xml-start-tag-node-name n) 0)
-  (when (js2-xml-start-tag-node-attrs n)
-    (insert " ")
-    (js2-print-list (js2-xml-start-tag-node-attrs n) " "))
-  (insert ">"))
-
-;; I -think- I'm going to make the parent node the corresponding start-tag,
-;; and add the end-tag to the kids list of the parent as well.
-(cl-defstruct (js2-xml-end-tag-node
-               (:include js2-xml-node)
-               (:constructor make-js2-xml-end-tag-node (&key (type js2-XML)
-                                                             (pos js2-ts-cursor)
-                                                             len name)))
-  "AST node for an XML end-tag.  Not currently used."
-  name)  ; a `js2-xml-name-node'
-
-(js2--struct-put 'js2-xml-end-tag-node 'js2-visitor 'js2-visit-xml-end-tag)
-(js2--struct-put 'js2-xml-end-tag-node 'js2-printer 'js2-print-xml-end-tag)
-
-(defun js2-visit-xml-end-tag (n v)
-  (js2-visit-ast (js2-xml-end-tag-node-name n) v))
-
-(defun js2-print-xml-end-tag (n i)
-  (insert (js2-make-pad i))
-  (insert "</")
-  (js2-print-ast (js2-xml-end-tag-node-name n) 0)
-  (insert ">"))
-
-(cl-defstruct (js2-xml-name-node
-               (:include js2-xml-node)
-               (:constructor make-js2-xml-name-node (&key (type js2-XML)
-                                                          (pos js2-ts-cursor)
-                                                          len namespace kids)))
-  "AST node for an E4X XML name.  Not currently used.
-Any XML name can be qualified with a namespace, hence the namespace field.
-Further, any E4X name can be comprised of arbitrary JavaScript {} expressions.
-The kids field is a list of `js2-name-node' and `js2-xml-js-expr-node'.
-For a simple name, the kids list has exactly one node, a `js2-name-node'."
-  namespace)  ; a `js2-string-node'
-
-(js2--struct-put 'js2-xml-name-node 'js2-visitor 'js2-visit-xml-name-node)
-(js2--struct-put 'js2-xml-name-node 'js2-printer 'js2-print-xml-name-node)
-
-(defun js2-visit-xml-name-node (n v)
-  (js2-visit-ast (js2-xml-name-node-namespace n) v))
-
-(defun js2-print-xml-name-node (n i)
-  (insert (js2-make-pad i))
-  (when (js2-xml-name-node-namespace n)
-    (js2-print-ast (js2-xml-name-node-namespace n) 0)
-    (insert "::"))
-  (dolist (kid (js2-xml-name-node-kids n))
-    (js2-print-ast kid 0)))
-
-(cl-defstruct (js2-xml-pi-node
-               (:include js2-xml-node)
-               (:constructor make-js2-xml-pi-node (&key (type js2-XML)
-                                                        (pos js2-ts-cursor)
-                                                        len name attrs)))
-  "AST node for an E4X XML processing instruction.  Not currently used."
-  name   ; a `js2-xml-name-node'
-  attrs) ; a list of `js2-xml-attr-node'
-
-(js2--struct-put 'js2-xml-pi-node 'js2-visitor 'js2-visit-xml-pi-node)
-(js2--struct-put 'js2-xml-pi-node 'js2-printer 'js2-print-xml-pi-node)
-
-(defun js2-visit-xml-pi-node (n v)
-  (js2-visit-ast (js2-xml-pi-node-name n) v)
-  (dolist (attr (js2-xml-pi-node-attrs n))
-    (js2-visit-ast attr v)))
-
-(defun js2-print-xml-pi-node (n i)
-  (insert (js2-make-pad i) "<?")
-  (js2-print-ast (js2-xml-pi-node-name n))
-  (when (js2-xml-pi-node-attrs n)
-    (insert " ")
-    (js2-print-list (js2-xml-pi-node-attrs n)))
-  (insert "?>"))
-
-(cl-defstruct (js2-xml-cdata-node
-               (:include js2-xml-node)
-               (:constructor make-js2-xml-cdata-node (&key (type js2-XML)
-                                                           (pos js2-ts-cursor)
-                                                           len content)))
-  "AST node for a CDATA escape section.  Not currently used."
-  content)  ; a `js2-string-node' with node-property 'quote-type 'cdata
-
-(js2--struct-put 'js2-xml-cdata-node 'js2-visitor 'js2-visit-xml-cdata-node)
-(js2--struct-put 'js2-xml-cdata-node 'js2-printer 'js2-print-xml-cdata-node)
-
-(defun js2-visit-xml-cdata-node (n v)
-  (js2-visit-ast (js2-xml-cdata-node-content n) v))
-
-(defun js2-print-xml-cdata-node (n i)
-  (insert (js2-make-pad i))
-  (js2-print-ast (js2-xml-cdata-node-content n)))
-
-(cl-defstruct (js2-xml-attr-node
-               (:include js2-xml-node)
-               (:constructor make-js2-attr-node (&key (type js2-XML)
-                                                      (pos js2-ts-cursor)
-                                                      len name value
-                                                      eq-pos quote-type)))
-  "AST node representing a foo='bar' XML attribute value.  Not yet used."
-  name   ; a `js2-xml-name-node'
-  value  ; a `js2-xml-name-node'
-  eq-pos ; buffer position of "=" sign
-  quote-type) ; 'single or 'double
-
-(js2--struct-put 'js2-xml-attr-node 'js2-visitor 'js2-visit-xml-attr-node)
-(js2--struct-put 'js2-xml-attr-node 'js2-printer 'js2-print-xml-attr-node)
-
-(defun js2-visit-xml-attr-node (n v)
-  (js2-visit-ast (js2-xml-attr-node-name n) v)
-  (js2-visit-ast (js2-xml-attr-node-value n) v))
-
-(defun js2-print-xml-attr-node (n i)
-  (let ((quote (if (eq (js2-xml-attr-node-quote-type n) 'single)
-                   "'"
-                 "\"")))
-    (insert (js2-make-pad i))
-    (js2-print-ast (js2-xml-attr-node-name n) 0)
-    (insert "=" quote)
-    (js2-print-ast (js2-xml-attr-node-value n) 0)
-    (insert quote)))
-
-(cl-defstruct (js2-xml-text-node
-               (:include js2-xml-node)
-               (:constructor make-js2-text-node (&key (type js2-XML)
-                                                      (pos js2-ts-cursor)
-                                                      len content)))
-  "AST node for an E4X XML text node.  Not currently used."
-  content)  ; a Lisp list of `js2-string-node' and `js2-xml-js-expr-node'
-
-(js2--struct-put 'js2-xml-text-node 'js2-visitor 'js2-visit-xml-text-node)
-(js2--struct-put 'js2-xml-text-node 'js2-printer 'js2-print-xml-text-node)
-
-(defun js2-visit-xml-text-node (n v)
-  (js2-visit-ast (js2-xml-text-node-content n) v))
-
-(defun js2-print-xml-text-node (n i)
-  (insert (js2-make-pad i))
-  (dolist (kid (js2-xml-text-node-content n))
-    (js2-print-ast kid)))
-
-(cl-defstruct (js2-xml-comment-node
-               (:include js2-xml-node)
-               (:constructor make-js2-xml-comment-node (&key (type js2-XML)
-                                                             (pos js2-ts-cursor)
-                                                             len)))
-  "AST node for E4X XML comment.  Not currently used.")
-
-(js2--struct-put 'js2-xml-comment-node 'js2-visitor 'js2-visit-none)
-(js2--struct-put 'js2-xml-comment-node 'js2-printer 'js2-print-xml-comment)
-
-(defun js2-print-xml-comment (n i)
-  (insert (js2-make-pad i)
-          (js2-node-string n)))
-
-;;; Node utilities
-
-(defsubst js2-node-line (n)
-  "Fetch the source line number at the start of node N.
-This is O(n) in the length of the source buffer; use prudently."
-  (1+ (count-lines (point-min) (js2-node-abs-pos n))))
-
-(defsubst js2-block-node-kid (n i)
-  "Return child I of node N, or nil if there aren't that many."
-  (nth i (js2-block-node-kids n)))
-
-(defsubst js2-block-node-first (n)
-  "Return first child of block node N, or nil if there is none."
-  (cl-first (js2-block-node-kids n)))
-
-(defun js2-node-root (n)
-  "Return the root of the AST containing N.
-If N has no parent pointer, returns N."
-  (let ((parent (js2-node-parent n)))
-    (if parent
-        (js2-node-root parent)
-      n)))
-
-(defsubst js2-node-short-name (n)
-  "Return the short name of node N as a string, e.g. `js2-if-node'."
-  (let ((name (symbol-name (aref n 0))))
-    (if (string-prefix-p "cl-struct-" name)
-        (substring (symbol-name (aref n 0))
-                   (length "cl-struct-"))
-      name)))
-
-(defun js2-node-child-list (node)
-  "Return the child list for NODE, a Lisp list of nodes.
-Works for block nodes, array nodes, obj literals, funarg lists,
-var decls and try nodes (for catch clauses).  Note that you should call
-`js2-block-node-kids' on the function body for the body statements.
-Returns nil for zero-length child lists or unsupported nodes."
-  (cond
-   ((js2-function-node-p node)
-    (js2-function-node-params node))
-   ((js2-block-node-p node)
-    (js2-block-node-kids node))
-   ((js2-try-node-p node)
-    (js2-try-node-catch-clauses node))
-   ((js2-array-node-p node)
-    (js2-array-node-elems node))
-   ((js2-object-node-p node)
-    (js2-object-node-elems node))
-   ((js2-call-node-p node)
-    (js2-call-node-args node))
-   ((js2-new-node-p node)
-    (js2-new-node-args node))
-   ((js2-var-decl-node-p node)
-    (js2-var-decl-node-kids node))
-   (t
-    nil)))
-
-(defun js2-node-set-child-list (node kids)
-  "Set the child list for NODE to KIDS."
-   (cond
-    ((js2-function-node-p node)
-     (setf (js2-function-node-params node) kids))
-    ((js2-block-node-p node)
-     (setf (js2-block-node-kids node) kids))
-    ((js2-try-node-p node)
-     (setf (js2-try-node-catch-clauses node) kids))
-    ((js2-array-node-p node)
-     (setf (js2-array-node-elems node) kids))
-    ((js2-object-node-p node)
-     (setf (js2-object-node-elems node) kids))
-    ((js2-call-node-p node)
-     (setf (js2-call-node-args node) kids))
-    ((js2-new-node-p node)
-     (setf (js2-new-node-args node) kids))
-    ((js2-var-decl-node-p node)
-     (setf (js2-var-decl-node-kids node) kids))
-    (t
-     (error "Unsupported node type: %s" (js2-node-short-name node))))
-   kids)
-
-;; All because Common Lisp doesn't support multiple inheritance for defstructs.
-(defconst js2-paren-expr-nodes
-  '(cl-struct-js2-comp-loop-node
-    cl-struct-js2-comp-node
-    cl-struct-js2-call-node
-    cl-struct-js2-catch-node
-    cl-struct-js2-do-node
-    cl-struct-js2-elem-get-node
-    cl-struct-js2-for-in-node
-    cl-struct-js2-for-node
-    cl-struct-js2-function-node
-    cl-struct-js2-if-node
-    cl-struct-js2-let-node
-    cl-struct-js2-new-node
-    cl-struct-js2-paren-node
-    cl-struct-js2-switch-node
-    cl-struct-js2-while-node
-    cl-struct-js2-with-node
-    cl-struct-js2-xml-dot-query-node)
-  "Node types that can have a parenthesized child expression.
-In particular, nodes that respond to `js2-node-lp' and `js2-node-rp'.")
-
-(defsubst js2-paren-expr-node-p (node)
-  "Return t for nodes that typically have a parenthesized child expression.
-Useful for computing the indentation anchors for arg-lists and conditions.
-Note that it may return a false positive, for instance when NODE is
-a `js2-new-node' and there are no arguments or parentheses."
-  (memq (aref node 0) js2-paren-expr-nodes))
-
-;; Fake polymorphism... yech.
-(defun js2-node-lp (node)
-  "Return relative left-paren position for NODE, if applicable.
-For `js2-elem-get-node' structs, returns left-bracket position.
-Note that the position may be nil in the case of a parse error."
-  (cond
-   ((js2-elem-get-node-p node)
-    (js2-elem-get-node-lb node))
-   ((js2-loop-node-p node)
-    (js2-loop-node-lp node))
-   ((js2-function-node-p node)
-    (js2-function-node-lp node))
-   ((js2-if-node-p node)
-    (js2-if-node-lp node))
-   ((js2-new-node-p node)
-    (js2-new-node-lp node))
-   ((js2-call-node-p node)
-    (js2-call-node-lp node))
-   ((js2-paren-node-p node)
-    0)
-   ((js2-switch-node-p node)
-    (js2-switch-node-lp node))
-   ((js2-catch-node-p node)
-    (js2-catch-node-lp node))
-   ((js2-let-node-p node)
-    (js2-let-node-lp node))
-   ((js2-comp-node-p node)
-    0)
-   ((js2-with-node-p node)
-    (js2-with-node-lp node))
-   ((js2-xml-dot-query-node-p node)
-    (1+ (js2-infix-node-op-pos node)))
-   (t
-    (error "Unsupported node type: %s" (js2-node-short-name node)))))
-
-;; Fake polymorphism... blech.
-(defun js2-node-rp (node)
-  "Return relative right-paren position for NODE, if applicable.
-For `js2-elem-get-node' structs, returns right-bracket position.
-Note that the position may be nil in the case of a parse error."
-  (cond
-   ((js2-elem-get-node-p node)
-    (js2-elem-get-node-rb node))
-   ((js2-loop-node-p node)
-    (js2-loop-node-rp node))
-   ((js2-function-node-p node)
-    (js2-function-node-rp node))
-   ((js2-if-node-p node)
-    (js2-if-node-rp node))
-   ((js2-new-node-p node)
-    (js2-new-node-rp node))
-   ((js2-call-node-p node)
-    (js2-call-node-rp node))
-   ((js2-paren-node-p node)
-    (1- (js2-node-len node)))
-   ((js2-switch-node-p node)
-    (js2-switch-node-rp node))
-   ((js2-catch-node-p node)
-    (js2-catch-node-rp node))
-   ((js2-let-node-p node)
-    (js2-let-node-rp node))
-   ((js2-comp-node-p node)
-    (1- (js2-node-len node)))
-   ((js2-with-node-p node)
-    (js2-with-node-rp node))
-   ((js2-xml-dot-query-node-p node)
-    (1+ (js2-xml-dot-query-node-rp node)))
-   (t
-    (error "Unsupported node type: %s" (js2-node-short-name node)))))
-
-(defsubst js2-node-first-child (node)
-  "Return the first element of `js2-node-child-list' for NODE."
-  (car (js2-node-child-list node)))
-
-(defsubst js2-node-last-child (node)
-  "Return the last element of `js2-node-last-child' for NODE."
-  (car (last (js2-node-child-list node))))
-
-(defun js2-node-prev-sibling (node)
-  "Return the previous statement in parent.
-Works for parents supported by `js2-node-child-list'.
-Returns nil if NODE is not in the parent, or PARENT is
-not a supported node, or if NODE is the first child."
-  (let* ((p (js2-node-parent node))
-         (kids (js2-node-child-list p))
-         (sib (car kids)))
-    (while (and kids
-                (not (eq node (cadr kids))))
-      (setq kids (cdr kids)
-            sib (car kids)))
-    sib))
-
-(defun js2-node-next-sibling (node)
-  "Return the next statement in parent block.
-Returns nil if NODE is not in the block, or PARENT is not
-a block node, or if NODE is the last statement."
-  (let* ((p (js2-node-parent node))
-         (kids (js2-node-child-list p)))
-    (while (and kids
-                (not (eq node (car kids))))
-      (setq kids (cdr kids)))
-    (cadr kids)))
-
-(defun js2-node-find-child-before (pos parent &optional after)
-  "Find the last child that starts before POS in parent.
-If AFTER is non-nil, returns first child starting after POS.
-POS is an absolute buffer position.  PARENT is any node
-supported by `js2-node-child-list'.
-Returns nil if no applicable child is found."
-  (let ((kids (if (js2-function-node-p parent)
-                  (js2-block-node-kids (js2-function-node-body parent))
-                (js2-node-child-list parent)))
-        (beg (js2-node-abs-pos (if (js2-function-node-p parent)
-                                   (js2-function-node-body parent)
-                                 parent)))
-        kid result fn
-        (continue t))
-    (setq fn (if after '>= '<))
-    (while (and kids continue)
-      (setq kid (car kids))
-      (if (funcall fn (+ beg (js2-node-pos kid)) pos)
-          (setq result kid
-                continue (not after))
-        (setq continue after))
-      (setq kids (cdr kids)))
-    result))
-
-(defun js2-node-find-child-after (pos parent)
-  "Find first child that starts after POS in parent.
-POS is an absolute buffer position.  PARENT is any node
-supported by `js2-node-child-list'.
-Returns nil if no applicable child is found."
-  (js2-node-find-child-before pos parent 'after))
-
-(defun js2-node-replace-child (pos parent new-node)
-  "Replace node at index POS in PARENT with NEW-NODE.
-Only works for parents supported by `js2-node-child-list'."
-  (let ((kids (js2-node-child-list parent))
-        (i 0))
-    (while (< i pos)
-      (setq kids (cdr kids)
-            i (1+ i)))
-    (setcar kids new-node)
-    (js2-node-add-children parent new-node)))
-
-(defun js2-node-buffer (n)
-  "Return the buffer associated with AST N.
-Returns nil if the buffer is not set as a property on the root
-node, or if parent links were not recorded during parsing."
-  (let ((root (js2-node-root n)))
-    (and root
-         (js2-ast-root-p root)
-         (js2-ast-root-buffer root))))
-
-(defun js2-block-node-push (n kid)
-  "Push js2-node KID onto the end of js2-block-node N's child list.
-KID is always added to the -end- of the kids list.
-Function also calls `js2-node-add-children' to add the parent link."
-  (let ((kids (js2-node-child-list n)))
-    (if kids
-        (setcdr kids (nconc (cdr kids) (list kid)))
-      (js2-node-set-child-list n (list kid)))
-    (js2-node-add-children n kid)))
-
-(defun js2-node-string (node)
-  (with-current-buffer (or (js2-node-buffer node)
-                           (error "No buffer available for node %s" node))
-    (let ((pos (js2-node-abs-pos node)))
-      (buffer-substring-no-properties pos (+ pos (js2-node-len node))))))
-
-;; Container for storing the node we're looking for in a traversal.
-(js2-deflocal js2-discovered-node nil)
-
-;; Keep track of absolute node position during traversals.
-(js2-deflocal js2-visitor-offset nil)
-
-(js2-deflocal js2-node-search-point nil)
-
-(when js2-mode-dev-mode-p
-  (defun js2-find-node-at-point ()
-    (interactive)
-    (let ((node (js2-node-at-point)))
-      (message "%s" (or node "No node found at point"))))
-  (defun js2-node-name-at-point ()
-    (interactive)
-    (let ((node (js2-node-at-point)))
-      (message "%s" (if node
-                        (js2-node-short-name node)
-                      "No node found at point.")))))
-
-(defun js2-node-at-point (&optional pos skip-comments)
-  "Return AST node at POS, a buffer position, defaulting to current point.
-The `js2-mode-ast' variable must be set to the current parse tree.
-Signals an error if the AST (`js2-mode-ast') is nil.
-Always returns a node - if it can't find one, it returns the root.
-If SKIP-COMMENTS is non-nil, comment nodes are ignored."
-  (let ((ast js2-mode-ast)
-        result)
-    (unless ast
-      (error "No JavaScript AST available"))
-    ;; Look through comments first, since they may be inside nodes that
-    ;; would otherwise report a match.
-    (setq pos (or pos (point))
-          result (if (> pos (js2-node-abs-end ast))
-                     ast
-                   (if (not skip-comments)
-                       (js2-comment-at-point pos))))
-    (unless result
-      (setq js2-discovered-node nil
-            js2-visitor-offset 0
-            js2-node-search-point pos)
-      (unwind-protect
-          (catch 'js2-visit-done
-            (js2-visit-ast ast #'js2-node-at-point-visitor))
-        (setq js2-visitor-offset nil
-              js2-node-search-point nil))
-      (setq result js2-discovered-node))
-    ;; may have found a comment beyond end of last child node,
-    ;; since visiting the ast-root looks at the comment-list last.
-    (if (and skip-comments
-             (js2-comment-node-p result))
-        (setq result nil))
-    (or result js2-mode-ast)))
-
-(defun js2-node-at-point-visitor (node end-p)
-  (let ((rel-pos (js2-node-pos node))
-        abs-pos
-        abs-end
-        (point js2-node-search-point))
-    (cond
-     (end-p
-      ;; this evaluates to a non-nil return value, even if it's zero
-      (cl-decf js2-visitor-offset rel-pos))
-     ;; we already looked for comments before visiting, and don't want them now
-     ((js2-comment-node-p node)
-      nil)
-     (t
-      (setq abs-pos (cl-incf js2-visitor-offset rel-pos)
-            ;; we only want to use the node if the point is before
-            ;; the last character position in the node, so we decrement
-            ;; the absolute end by 1.
-            abs-end (+ abs-pos (js2-node-len node) -1))
-      (cond
-       ;; If this node starts after search-point, stop the search.
-       ((> abs-pos point)
-        (throw 'js2-visit-done nil))
-       ;; If this node ends before the search-point, don't check kids.
-       ((> point abs-end)
-        nil)
-       (t
-        ;; Otherwise point is within this node, possibly in a child.
-        (setq js2-discovered-node node)
-        t))))))  ; keep processing kids to look for more specific match
-
-(defsubst js2-block-comment-p (node)
-  "Return non-nil if NODE is a comment node of format `jsdoc' or `block'."
-  (and (js2-comment-node-p node)
-       (memq (js2-comment-node-format node) '(jsdoc block))))
-
-;; TODO:  put the comments in a vector and binary-search them instead
-(defun js2-comment-at-point (&optional pos)
-  "Look through scanned comment nodes for one containing POS.
-POS is a buffer position that defaults to current point.
-Function returns nil if POS was not in any comment node."
-  (let ((ast js2-mode-ast)
-        (x (or pos (point)))
-        beg end)
-    (unless ast
-      (error "No JavaScript AST available"))
-    (catch 'done
-      ;; Comments are stored in lexical order.
-      (dolist (comment (js2-ast-root-comments ast) nil)
-        (setq beg (js2-node-abs-pos comment)
-              end (+ beg (js2-node-len comment)))
-        (if (and (>= x beg)
-                 (<= x end))
-          (throw 'done comment))))))
-
-(defun js2-comments-between (start end comments-list)
-  "Return comment nodes between START and END, nil if not found.
-START and END are absolute positions in current buffer.
-COMMENTS-LIST is the comments list to check."
-  (let (comments c-start c-end)
-    (nreverse
-      (dolist (comment comments-list comments)
-        (setq c-start (js2-node-abs-pos comment)
-              c-end (1- (+ c-start (js2-node-len comment))))
-        (unless (or (< c-end start)
-                    (> c-start end))
-          (push comment comments))))))
-
-(defun js2-mode-find-parent-fn (node)
-  "Find function enclosing NODE.
-Returns nil if NODE is not inside a function."
-  (setq node (js2-node-parent node))
-  (while (and node (not (js2-function-node-p node)))
-    (setq node (js2-node-parent node)))
-  (and (js2-function-node-p node) node))
-
-(defun js2-mode-find-enclosing-fn (node)
-  "Find function or root enclosing NODE."
-  (if (js2-ast-root-p node)
-      node
-    (setq node (js2-node-parent node))
-    (while (not (or (js2-ast-root-p node)
-                    (js2-function-node-p node)))
-      (setq node (js2-node-parent node)))
-    node))
-
- (defun js2-mode-find-enclosing-node (beg end)
-  "Find node fully enclosing BEG and END."
-  (let ((node (js2-node-at-point beg))
-        pos
-        (continue t))
-    (while continue
-      (if (or (js2-ast-root-p node)
-              (and
-               (<= (setq pos (js2-node-abs-pos node)) beg)
-               (>= (+ pos (js2-node-len node)) end)))
-          (setq continue nil)
-        (setq node (js2-node-parent node))))
-    node))
-
-(defun js2-node-parent-script-or-fn (node)
-  "Find script or function immediately enclosing NODE.
-If NODE is the ast-root, returns nil."
-  (if (js2-ast-root-p node)
-      nil
-    (setq node (js2-node-parent node))
-    (while (and node (not (or (js2-function-node-p node)
-                              (js2-script-node-p node))))
-      (setq node (js2-node-parent node)))
-    node))
-
-(defun js2-node-is-descendant (node ancestor)
-  "Return t if NODE is a descendant of ANCESTOR."
-  (while (and node
-              (not (eq node ancestor)))
-    (setq node (js2-node-parent node)))
-  node)
-
-;;; visitor infrastructure
-
-(defun js2-visit-none (_node _callback)
-  "Visitor for AST node that have no node children."
-  nil)
-
-(defun js2-print-none (_node _indent)
-  "Visitor for AST node with no printed representation.")
-
-(defun js2-print-body (node indent)
-  "Print a statement, or a block without braces."
-  (if (js2-block-node-p node)
-      (dolist (kid (js2-block-node-kids node))
-        (js2-print-ast kid indent))
-    (js2-print-ast node indent)))
-
-(defun js2-print-list (args &optional delimiter)
-  (cl-loop with len = (length args)
-           for arg in args
-           for count from 1
-           do
-           (when arg (js2-print-ast arg 0))
-           (if (< count len)
-               (insert (or delimiter ", ")))))
-
-(defun js2-print-tree (ast)
-  "Prints an AST to the current buffer.
-Makes `js2-ast-parent-nodes' available to the printer functions."
-  (let ((max-lisp-eval-depth (max max-lisp-eval-depth 1500)))
-    (js2-print-ast ast)))
-
-(defun js2-print-ast (node &optional indent)
-  "Helper function for printing AST nodes.
-Requires `js2-ast-parent-nodes' to be non-nil.
-You should use `js2-print-tree' instead of this function."
-  (let ((printer (get (aref node 0) 'js2-printer))
-        (i (or indent 0)))
-    ;; TODO:  wedge comments in here somewhere
-    (if printer
-        (funcall printer node i))))
-
-(defconst js2-side-effecting-tokens
-  (let ((tokens (make-bool-vector js2-num-tokens nil)))
-    (dolist (tt (list js2-ASSIGN
-                      js2-ASSIGN_ADD
-                      js2-ASSIGN_BITAND
-                      js2-ASSIGN_BITOR
-                      js2-ASSIGN_BITXOR
-                      js2-ASSIGN_DIV
-                      js2-ASSIGN_LSH
-                      js2-ASSIGN_MOD
-                      js2-ASSIGN_MUL
-                      js2-ASSIGN_RSH
-                      js2-ASSIGN_SUB
-                      js2-ASSIGN_URSH
-                      js2-ASSIGN_EXPON
-                      js2-BLOCK
-                      js2-BREAK
-                      js2-CALL
-                      js2-CATCH
-                      js2-CATCH_SCOPE
-                      js2-CLASS
-                      js2-CONST
-                      js2-CONTINUE
-                      js2-DEBUGGER
-                      js2-DEC
-                      js2-DELPROP
-                      js2-DEL_REF
-                      js2-DO
-                      js2-ELSE
-                      js2-EMPTY
-                      js2-ENTERWITH
-                      js2-EXPORT
-                      js2-EXPR_RESULT
-                      js2-FINALLY
-                      js2-FOR
-                      js2-FUNCTION
-                      js2-GOTO
-                      js2-IF
-                      js2-IFEQ
-                      js2-IFNE
-                      js2-IMPORT
-                      js2-INC
-                      js2-JSR
-                      js2-LABEL
-                      js2-LEAVEWITH
-                      js2-LET
-                      js2-LETEXPR
-                      js2-LOCAL_BLOCK
-                      js2-LOOP
-                      js2-NEW
-                      js2-REF_CALL
-                      js2-RETHROW
-                      js2-RETURN
-                      js2-RETURN_RESULT
-                      js2-SEMI
-                      js2-SETELEM
-                      js2-SETELEM_OP
-                      js2-SETNAME
-                      js2-SETPROP
-                      js2-SETPROP_OP
-                      js2-SETVAR
-                      js2-SET_REF
-                      js2-SET_REF_OP
-                      js2-SWITCH
-                      js2-TARGET
-                      js2-THROW
-                      js2-TRY
-                      js2-VAR
-                      js2-WHILE
-                      js2-WITH
-                      js2-WITHEXPR
-                      js2-YIELD))
-      (aset tokens tt t))
-    tokens))
-
-(defun js2-node-has-side-effects (node)
-  "Return t if NODE has side effects."
-  (when node  ; makes it easier to handle malformed expressions
-    (let ((tt (js2-node-type node)))
-      (cond
-       ;; This doubtless needs some work, since EXPR_VOID is used
-       ;; in several ways in Rhino and I may not have caught them all.
-       ;; I'll wait for people to notice incorrect warnings.
-       ((and (= tt js2-EXPR_VOID)
-             (js2-expr-stmt-node-p node)) ; but not if EXPR_RESULT
-        (let ((expr (js2-expr-stmt-node-expr node)))
-          (or (js2-node-has-side-effects expr)
-              (when (js2-string-node-p expr)
-                (member (js2-string-node-value expr) '("use strict" "use asm"))))))
-       ((= tt js2-AWAIT) t)
-       ((= tt js2-COMMA)
-        (js2-node-has-side-effects (js2-infix-node-right node)))
-       ((or (= tt js2-AND)
-            (= tt js2-OR))
-        (or (js2-node-has-side-effects (js2-infix-node-right node))
-            (js2-node-has-side-effects (js2-infix-node-left node))))
-       ((= tt js2-HOOK)
-        (and (js2-node-has-side-effects (js2-cond-node-true-expr node))
-             (js2-node-has-side-effects (js2-cond-node-false-expr node))))
-       ((js2-paren-node-p node)
-        (js2-node-has-side-effects (js2-paren-node-expr node)))
-       ((= tt js2-ERROR) ; avoid cascaded error messages
-        nil)
-       ((or (and js2-instanceof-has-side-effects (= tt js2-INSTANCEOF))
-            (and js2-getprop-has-side-effects (= tt js2-GETPROP)))
-        t)
-       (t
-        (aref js2-side-effecting-tokens tt))))))
-
-(defconst js2-stmt-node-types
-  (list js2-BLOCK
-        js2-BREAK
-        js2-CONTINUE
-        js2-DEFAULT  ; e4x "default xml namespace" statement
-        js2-DO
-        js2-EXPORT
-        js2-EXPR_RESULT
-        js2-EXPR_VOID
-        js2-FOR
-        js2-IF
-        js2-IMPORT
-        js2-RETURN
-        js2-SWITCH
-        js2-THROW
-        js2-TRY
-        js2-WHILE
-        js2-WITH)
-  "Node types that only appear in statement contexts.
-The list does not include nodes that always appear as the child
-of another specific statement type, such as switch-cases,
-catch and finally blocks, and else-clauses.  The list also excludes
-nodes like yield, let and var, which may appear in either expression
-or statement context, and in the latter context always have a
-`js2-expr-stmt-node' parent.  Finally, the list does not include
-functions or scripts, which are treated separately from statements
-by the JavaScript parser and runtime.")
-
-(defun js2-stmt-node-p (node)
-  "Heuristic for figuring out if NODE is a statement.
-Some node types can appear in either an expression context or a
-statement context, e.g. let-nodes, yield-nodes, and var-decl nodes.
-For these node types in a statement context, the parent will be a
-`js2-expr-stmt-node'.
-Functions aren't included in the check."
-  (memq (js2-node-type node) js2-stmt-node-types))
-
-(defun js2-mode-find-first-stmt (node)
-  "Search upward starting from NODE looking for a statement.
-For purposes of this function, a `js2-function-node' counts."
-  (while (not (or (js2-stmt-node-p node)
-                  (js2-function-node-p node)))
-    (setq node (js2-node-parent node)))
-  node)
-
-(defun js2-node-parent-stmt (node)
-  "Return the node's first ancestor that is a statement.
-Returns nil if NODE is a `js2-ast-root'.  Note that any expression
-appearing in a statement context will have a parent that is a
-`js2-expr-stmt-node' that will be returned by this function."
-  (let ((parent (js2-node-parent node)))
-    (if (or (null parent)
-            (js2-stmt-node-p parent)
-            (and (js2-function-node-p parent)
-                 (eq (js2-function-node-form parent) 'FUNCTION_STATEMENT)))
-        parent
-      (js2-node-parent-stmt parent))))
-
-;; In the Mozilla Rhino sources, Roshan James writes:
-;;  Does consistent-return analysis on the function body when strict mode is
-;;  enabled.
-;;
-;;    function (x) { return (x+1) }
-;;
-;;  is ok, but
-;;
-;;    function (x) { if (x < 0) return (x+1); }
-;;
-;;  is not because the function can potentially return a value when the
-;;  condition is satisfied and if not, the function does not explicitly
-;;  return a value.
-;;
-;;  This extends to checking mismatches such as "return" and "return <value>"
-;;  used in the same function. Warnings are not emitted if inconsistent
-;;  returns exist in code that can be statically shown to be unreachable.
-;;  Ex.
-;;    function (x) { while (true) { ... if (..) { return value } ... } }
-;;
-;;  emits no warning. However if the loop had a break statement, then a
-;;  warning would be emitted.
-;;
-;;  The consistency analysis looks at control structures such as loops, ifs,
-;;  switch, try-catch-finally blocks, examines the reachable code paths and
-;;  warns the user about an inconsistent set of termination possibilities.
-;;
-;;  These flags enumerate the possible ways a statement/function can
-;;  terminate. These flags are used by endCheck() and by the Parser to
-;;  detect inconsistent return usage.
-;;
-;;  END_UNREACHED is reserved for code paths that are assumed to always be
-;;  able to execute (example: throw, continue)
-;;
-;;  END_DROPS_OFF indicates if the statement can transfer control to the
-;;  next one. Statement such as return dont. A compound statement may have
-;;  some branch that drops off control to the next statement.
-;;
-;;  END_RETURNS indicates that the statement can return with no value.
-;;  END_RETURNS_VALUE indicates that the statement can return a value.
-;;
-;;  A compound statement such as
-;;  if (condition) {
-;;    return value;
-;;  }
-;;  Will be detected as (END_DROPS_OFF | END_RETURN_VALUE) by endCheck()
-
-(defconst js2-END_UNREACHED 0)
-(defconst js2-END_DROPS_OFF 1)
-(defconst js2-END_RETURNS 2)
-(defconst js2-END_RETURNS_VALUE 4)
-(defconst js2-END_YIELDS 8)
-
-(defun js2-has-consistent-return-usage (node)
-  "Check that every return usage in a function body is consistent.
-Returns t if the function satisfies strict mode requirement."
-  (let ((n (js2-end-check node)))
-    ;; either it doesn't return a value in any branch...
-    (or (js2-flag-not-set-p n js2-END_RETURNS_VALUE)
-        ;; or it returns a value (or is unreached) at every branch
-        (js2-flag-not-set-p n (logior js2-END_DROPS_OFF
-                                      js2-END_RETURNS
-                                      js2-END_YIELDS)))))
-
-(defun js2-end-check-if (node)
-  "Ensure that return usage in then/else blocks is consistent.
-If there is no else block, then the return statement can fall through.
-Returns logical OR of END_* flags"
-  (let ((th (js2-if-node-then-part node))
-        (el (js2-if-node-else-part node)))
-    (if (null th)
-        js2-END_UNREACHED
-      (logior (js2-end-check th) (if el
-                                     (js2-end-check el)
-                                   js2-END_DROPS_OFF)))))
-
-(defun js2-end-check-switch (node)
-  "Consistency of return statements is checked between the case statements.
-If there is no default, then the switch can fall through. If there is a
-default, we check to see if all code paths in the default return or if
-there is a code path that can fall through.
-Returns logical OR of END_* flags."
-  (let ((rv js2-END_UNREACHED)
-        default-case)
-    ;; examine the cases
-    (catch 'break
-      (dolist (c (js2-switch-node-cases node))
-        (if (js2-case-node-expr c)
-            (js2-set-flag rv (js2-end-check-block c))
-          (setq default-case c)
-          (throw 'break nil))))
-    ;; we don't care how the cases drop into each other
-    (js2-clear-flag rv js2-END_DROPS_OFF)
-    ;; examine the default
-    (js2-set-flag rv (if default-case
-                         (js2-end-check default-case)
-                       js2-END_DROPS_OFF))
-    rv))
-
-(defun js2-end-check-try (node)
- "If the block has a finally, return consistency is checked in the
-finally block. If all code paths in the finally return, then the
-returns in the try-catch blocks don't matter. If there is a code path
-that does not return or if there is no finally block, the returns
-of the try and catch blocks are checked for mismatch.
-Returns logical OR of END_* flags."
- (let ((finally (js2-try-node-finally-block node))
-       rv)
-   ;; check the finally if it exists
-   (setq rv (if finally
-                (js2-end-check (js2-finally-node-body finally))
-              js2-END_DROPS_OFF))
-   ;; If the finally block always returns, then none of the returns
-   ;; in the try or catch blocks matter.
-   (when (js2-flag-set-p rv js2-END_DROPS_OFF)
-     (js2-clear-flag rv js2-END_DROPS_OFF)
-     ;; examine the try block
-     (js2-set-flag rv (js2-end-check (js2-try-node-try-block node)))
-     ;; check each catch block
-     (dolist (cb (js2-try-node-catch-clauses node))
-       (js2-set-flag rv (js2-end-check cb))))
-   rv))
-
-(defun js2-end-check-loop (node)
-  "Return statement in the loop body must be consistent.
-The default assumption for any kind of a loop is that it will eventually
-terminate.  The only exception is a loop with a constant true condition.
-Code that follows such a loop is examined only if one can determine
-statically that there is a break out of the loop.
-
-    for(... ; ... ; ...) {}
-    for(... in ... ) {}
-    while(...) { }
-    do { } while(...)
-
-Returns logical OR of END_* flags."
-  (let ((rv (js2-end-check (js2-loop-node-body node)))
-        (condition (cond
-                    ((js2-while-node-p node)
-                     (js2-while-node-condition node))
-                     ((js2-do-node-p node)
-                      (js2-do-node-condition node))
-                     ((js2-for-node-p node)
-                      (js2-for-node-condition node)))))
-
-    ;; check to see if the loop condition is always true
-    (if (and condition
-             (eq (js2-always-defined-boolean-p condition) 'ALWAYS_TRUE))
-        (js2-clear-flag rv js2-END_DROPS_OFF))
-
-    ;; look for effect of breaks
-    (js2-set-flag rv (js2-node-get-prop node
-                                        'CONTROL_BLOCK_PROP
-                                        js2-END_UNREACHED))
-    rv))
-
-(defun js2-end-check-block (node)
-  "A general block of code is examined statement by statement.
-If any statement (even a compound one) returns in all branches, then
-subsequent statements are not examined.
-Returns logical OR of END_* flags."
-  (let* ((rv js2-END_DROPS_OFF)
-         (kids (js2-block-node-kids node))
-         (n (car kids)))
-    ;; Check each statement.  If the statement can continue onto the next
-    ;; one (i.e. END_DROPS_OFF is set), then check the next statement.
-    (while (and n (js2-flag-set-p rv js2-END_DROPS_OFF))
-      (js2-clear-flag rv js2-END_DROPS_OFF)
-      (js2-set-flag rv (js2-end-check n))
-      (setq kids (cdr kids)
-            n (car kids)))
-    rv))
-
-(defun js2-end-check-label (node)
-  "A labeled statement implies that there may be a break to the label.
-The function processes the labeled statement and then checks the
-CONTROL_BLOCK_PROP property to see if there is ever a break to the
-particular label.
-Returns logical OR of END_* flags."
-  (let ((rv (js2-end-check (js2-labeled-stmt-node-stmt node))))
-    (logior rv (js2-node-get-prop node
-                                  'CONTROL_BLOCK_PROP
-                                  js2-END_UNREACHED))))
-
-(defun js2-end-check-break (node)
-  "When a break is encountered annotate the statement being broken
-out of by setting its CONTROL_BLOCK_PROP property.
-Returns logical OR of END_* flags."
-  (and (js2-break-node-target node)
-       (js2-node-set-prop (js2-break-node-target node)
-                          'CONTROL_BLOCK_PROP
-                          js2-END_DROPS_OFF))
-  js2-END_UNREACHED)
-
-(defun js2-end-check (node)
-  "Examine the body of a function, doing a basic reachability analysis.
-Returns a combination of flags END_* flags that indicate
-how the function execution can terminate. These constitute only the
-pessimistic set of termination conditions. It is possible that at
-runtime certain code paths will never be actually taken. Hence this
-analysis will flag errors in cases where there may not be errors.
-Returns logical OR of END_* flags"
-  (let (kid)
-    (cond
-     ((js2-break-node-p node)
-      (js2-end-check-break node))
-     ((js2-expr-stmt-node-p node)
-      (if (setq kid (js2-expr-stmt-node-expr node))
-          (js2-end-check kid)
-        js2-END_DROPS_OFF))
-     ((or (js2-continue-node-p node)
-          (js2-throw-node-p node))
-      js2-END_UNREACHED)
-     ((js2-return-node-p node)
-      (if (setq kid (js2-return-node-retval node))
-          js2-END_RETURNS_VALUE
-        js2-END_RETURNS))
-     ((js2-loop-node-p node)
-      (js2-end-check-loop node))
-     ((js2-switch-node-p node)
-      (js2-end-check-switch node))
-     ((js2-labeled-stmt-node-p node)
-      (js2-end-check-label node))
-     ((js2-if-node-p node)
-      (js2-end-check-if node))
-     ((js2-try-node-p node)
-      (js2-end-check-try node))
-     ((js2-block-node-p node)
-      (if (null (js2-block-node-kids node))
-          js2-END_DROPS_OFF
-        (js2-end-check-block node)))
-     ((js2-yield-node-p node)
-      js2-END_YIELDS)
-     (t
-      js2-END_DROPS_OFF))))
-
-(defun js2-always-defined-boolean-p (node)
-  "Check if NODE always evaluates to true or false in boolean context.
-Returns 'ALWAYS_TRUE, 'ALWAYS_FALSE, or nil if it's neither always true
-nor always false."
-  (let ((tt (js2-node-type node))
-        num)
-    (cond
-     ((or (= tt js2-FALSE) (= tt js2-NULL))
-      'ALWAYS_FALSE)
-     ((= tt js2-TRUE)
-      'ALWAYS_TRUE)
-     ((= tt js2-NUMBER)
-      (setq num (js2-number-node-num-value node))
-      (if (and (not (eq num 0.0e+NaN))
-               (not (zerop num)))
-          'ALWAYS_TRUE
-        'ALWAYS_FALSE))
-     (t
-      nil))))
-
-;;; Scanner -- a port of Mozilla Rhino's lexer.
-;; Corresponds to Rhino files Token.java and TokenStream.java.
-
-(defvar js2-tokens nil
-  "List of all defined token names.")  ; initialized in `js2-token-names'
-
-(defconst js2-token-names
-  (let* ((names (make-vector js2-num-tokens -1))
-         (case-fold-search nil)  ; only match js2-UPPER_CASE
-         (syms (apropos-internal "^js2-\\(?:[[:upper:]_]+\\)")))
-    (cl-loop for sym in syms
-             for i from 0
-             do
-             (unless (or (memq sym '(js2-EOF_CHAR js2-ERROR))
-                         (not (boundp sym)))
-               (aset names (symbol-value sym)           ; code, e.g. 152
-                     (downcase
-                      (substring (symbol-name sym) 4))) ; name, e.g. "let"
-               (push sym js2-tokens)))
-    names)
-  "Vector mapping int values to token string names, sans `js2-' prefix.")
-
-(defun js2-tt-name (tok)
-  "Return a string name for TOK, a token symbol or code.
-Signals an error if it's not a recognized token."
-  (let ((code tok))
-    (if (symbolp tok)
-        (setq code (symbol-value tok)))
-    (if (eq code -1)
-        "ERROR"
-      (if (and (numberp code)
-               (not (cl-minusp code))
-               (< code js2-num-tokens))
-          (aref js2-token-names code)
-        (error "Invalid token: %s" code)))))
-
-(defsubst js2-tt-sym (tok)
-  "Return symbol for TOK given its code, e.g. 'js2-LP for code 86."
-  (intern (js2-tt-name tok)))
-
-(defconst js2-token-codes
-  (let ((table (make-hash-table :test 'eq :size 256)))
-    (cl-loop for name across js2-token-names
-             for sym = (intern (concat "js2-" (upcase name)))
-             do
-             (puthash sym (symbol-value sym) table))
-    ;; clean up a few that are "wrong" in Rhino's token codes
-    (puthash 'js2-DELETE js2-DELPROP table)
-    table)
-  "Hashtable mapping token type symbols to their bytecodes.")
-
-(defsubst js2-tt-code (sym)
-  "Return code for token symbol SYM, e.g. 86 for 'js2-LP."
-  (or (gethash sym js2-token-codes)
-      (error "Invalid token symbol: %s " sym)))  ; signal code bug
-
-(defun js2-report-scan-error (msg &optional no-throw beg len)
-  (setf (js2-token-end (js2-current-token)) js2-ts-cursor)
-  (js2-report-error msg nil
-                    (or beg (js2-current-token-beg))
-                    (or len (js2-current-token-len)))
-  (unless no-throw
-    (throw 'return js2-ERROR)))
-
-(defun js2-set-string-from-buffer (token)
-  "Set `string' and `end' slots for TOKEN, return the string."
-  (setf (js2-token-end token) js2-ts-cursor
-        (js2-token-string token) (js2-collect-string js2-ts-string-buffer)))
-
-;; TODO:  could potentially avoid a lot of consing by allocating a
-;; char buffer the way Rhino does.
-(defsubst js2-add-to-string (c)
-  (push c js2-ts-string-buffer))
-
-;; Note that when we "read" the end-of-file, we advance js2-ts-cursor
-;; to (1+ (point-max)), which lets the scanner treat end-of-file like
-;; any other character:  when it's not part of the current token, we
-;; unget it, allowing it to be read again by the following call.
-(defsubst js2-unget-char ()
-  (cl-decf js2-ts-cursor))
-
-;; Rhino distinguishes \r and \n line endings.  We don't need to
-;; because we only scan from Emacs buffers, which always use \n.
-(defun js2-get-char ()
-  "Read and return the next character from the input buffer.
-Increments `js2-ts-lineno' if the return value is a newline char.
-Updates `js2-ts-cursor' to the point after the returned char.
-Returns `js2-EOF_CHAR' if we hit the end of the buffer.
-Also updates `js2-ts-hit-eof' and `js2-ts-line-start' as needed."
-  (let (c)
-    ;; check for end of buffer
-    (if (>= js2-ts-cursor (point-max))
-        (setq js2-ts-hit-eof t
-              js2-ts-cursor (1+ js2-ts-cursor)
-              c js2-EOF_CHAR)  ; return value
-      ;; otherwise read next char
-      (setq c (char-before (cl-incf js2-ts-cursor)))
-      ;; if we read a newline, update counters
-      (if (= c ?\n)
-          (setq js2-ts-line-start js2-ts-cursor
-                js2-ts-lineno (1+ js2-ts-lineno)))
-      ;; TODO:  skip over format characters
-      c)))
-
-(defun js2-read-unicode-escape ()
-  "Read a \\uNNNN sequence from the input.
-Assumes the ?\ and ?u have already been read.
-Returns the unicode character, or nil if it wasn't a valid character.
-Doesn't change the values of any scanner variables."
-  ;; I really wish I knew a better way to do this, but I can't
-  ;; find the Emacs function that takes a 16-bit int and converts
-  ;; it to a Unicode/utf-8 character.  So I basically eval it with (read).
-  ;; Have to first check that it's 4 hex characters or it may stop
-  ;; the read early.
-  (ignore-errors
-    (let ((s (buffer-substring-no-properties js2-ts-cursor
-                                             (+ 4 js2-ts-cursor))))
-      (if (string-match "[0-9a-fA-F]\\{4\\}" s)
-          (read (concat "?\\u" s))))))
-
-(defun js2-match-char (test)
-  "Consume and return next character if it matches TEST, a character.
-Returns nil and consumes nothing if TEST is not the next character."
-  (let ((c (js2-get-char)))
-    (if (eq c test)
-        t
-      (js2-unget-char)
-      nil)))
-
-(defun js2-peek-char ()
-  (prog1
-      (js2-get-char)
-    (js2-unget-char)))
-
-(defun js2-identifier-start-p (c)
-  "Is C a valid start to an ES5 Identifier?
-See http://es5.github.io/#x7.6"
-  (or
-   (memq c '(?$ ?_))
-   (memq (get-char-code-property c 'general-category)
-         ;; Letters
-         '(Lu Ll Lt Lm Lo Nl))))
-
-(defun js2-identifier-part-p (c)
-  "Is C a valid part of an ES5 Identifier?
-See http://es5.github.io/#x7.6"
-  (or
-   (memq c '(?$ ?_ ?\u200c  ?\u200d))
-   (memq (get-char-code-property c 'general-category)
-         '(;; Letters
-           Lu Ll Lt Lm Lo Nl
-           ;; Combining Marks
-           Mn Mc
-           ;; Digits
-           Nd
-           ;; Connector Punctuation
-           Pc))))
-
-(defun js2-alpha-p (c)
-  (cond ((and (<= ?A c) (<= c ?Z)) t)
-        ((and (<= ?a c) (<= c ?z)) t)
-        (t nil)))
-
-(defsubst js2-digit-p (c)
-  (and (<= ?0 c) (<= c ?9)))
-
-(defun js2-js-space-p (c)
-  (if (<= c 127)
-      (memq c '(#x20 #x9 #xB #xC #xD))
-    (or
-     (eq c #xA0)
-     ;; TODO:  change this nil to check for Unicode space character
-     nil)))
-
-(defconst js2-eol-chars (list js2-EOF_CHAR ?\n ?\r))
-
-(defun js2-skip-line ()
-  "Skip to end of line."
-  (while (not (memq (js2-get-char) js2-eol-chars)))
-  (js2-unget-char)
-  (setf (js2-token-end (js2-current-token)) js2-ts-cursor))
-
-(defun js2-init-scanner (&optional buf line)
-  "Create token stream for BUF starting on LINE.
-BUF defaults to `current-buffer' and LINE defaults to 1.
-
-A buffer can only have one scanner active at a time, which yields
-dramatically simpler code than using a defstruct.  If you need to
-have simultaneous scanners in a buffer, copy the regions to scan
-into temp buffers."
-  (with-current-buffer (or buf (current-buffer))
-    (setq js2-ts-dirty-line nil
-          js2-ts-hit-eof nil
-          js2-ts-line-start 0
-          js2-ts-lineno (or line 1)
-          js2-ts-line-end-char -1
-          js2-ts-cursor (point-min)
-          js2-ti-tokens (make-vector js2-ti-ntokens nil)
-          js2-ti-tokens-cursor 0
-          js2-ti-lookahead 0
-          js2-ts-is-xml-attribute nil
-          js2-ts-xml-is-tag-content nil
-          js2-ts-xml-open-tags-count 0
-          js2-ts-string-buffer nil)))
-
-;; This function uses the cached op, string and number fields in
-;; TokenStream; if getToken has been called since the passed token
-;; was scanned, the op or string printed may be incorrect.
-(defun js2-token-to-string (token)
-  ;; Not sure where this function is used in Rhino.  Not tested.
-  (if (not js2-debug-print-trees)
-      ""
-    (let ((name (js2-tt-name token)))
-      (cond
-       ((memq token '(js2-STRING js2-REGEXP js2-NAME
-                      js2-TEMPLATE_HEAD js2-NO_SUBS_TEMPLATE))
-        (concat name " `" (js2-current-token-string) "'"))
-       ((eq token js2-NUMBER)
-        (format "NUMBER %g" (js2-token-number (js2-current-token))))
-       (t
-        name)))))
-
-(defconst js2-keywords
-  '(break
-    case catch class const continue
-    debugger default delete do
-    else extends export
-    false finally for function
-    if in instanceof import
-    let
-    new null
-    return
-    super switch
-    this throw true try typeof
-    var void
-    while with
-    yield))
-
-;; Token names aren't exactly the same as the keywords, unfortunately.
-;; E.g. delete is js2-DELPROP.
-(defconst js2-kwd-tokens
-  (let ((table (make-vector js2-num-tokens nil))
-        (tokens
-         (list js2-BREAK
-               js2-CASE js2-CATCH js2-CLASS js2-CONST js2-CONTINUE
-               js2-DEBUGGER js2-DEFAULT js2-DELPROP js2-DO
-               js2-ELSE js2-EXPORT
-               js2-ELSE js2-EXTENDS js2-EXPORT
-               js2-FALSE js2-FINALLY js2-FOR js2-FUNCTION
-               js2-IF js2-IN js2-INSTANCEOF js2-IMPORT
-               js2-LET
-               js2-NEW js2-NULL
-               js2-RETURN
-               js2-SUPER js2-SWITCH
-               js2-THIS js2-THROW js2-TRUE js2-TRY js2-TYPEOF
-               js2-VAR
-               js2-WHILE js2-WITH
-               js2-YIELD)))
-    (dolist (i tokens)
-      (aset table i 'font-lock-keyword-face))
-    (aset table js2-STRING 'font-lock-string-face)
-    (aset table js2-REGEXP 'font-lock-string-face)
-    (aset table js2-NO_SUBS_TEMPLATE 'font-lock-string-face)
-    (aset table js2-TEMPLATE_HEAD 'font-lock-string-face)
-    (aset table js2-COMMENT 'font-lock-comment-face)
-    (aset table js2-THIS 'font-lock-builtin-face)
-    (aset table js2-SUPER 'font-lock-builtin-face)
-    (aset table js2-VOID 'font-lock-constant-face)
-    (aset table js2-NULL 'font-lock-constant-face)
-    (aset table js2-TRUE 'font-lock-constant-face)
-    (aset table js2-FALSE 'font-lock-constant-face)
-    (aset table js2-NOT 'font-lock-negation-char-face)
-    table)
-  "Vector whose values are non-nil for tokens that are keywords.
-The values are default faces to use for highlighting the keywords.")
-
-;; FIXME: Support strict mode-only future reserved words, after we know
-;; which parts scopes are in strict mode, and which are not.
-(defconst js2-reserved-words '(class enum export extends import static super)
-  "Future reserved keywords in ECMAScript 5.1.")
-
-(defconst js2-keyword-names
-  (let ((table (make-hash-table :test 'equal)))
-    (cl-loop for k in js2-keywords
-             do (puthash
-                 (symbol-name k)                            ; instanceof
-                 (intern (concat "js2-"
-                                 (upcase (symbol-name k)))) ; js2-INSTANCEOF
-                 table))
-    table)
-  "JavaScript keywords by name, mapped to their symbols.")
-
-(defconst js2-reserved-word-names
-  (let ((table (make-hash-table :test 'equal)))
-    (cl-loop for k in js2-reserved-words
-             do
-             (puthash (symbol-name k) 'js2-RESERVED table))
-    table)
-  "JavaScript reserved words by name, mapped to 'js2-RESERVED.")
-
-(defun js2-collect-string (buf)
-  "Convert BUF, a list of chars, to a string.
-Reverses BUF before converting."
-  (if buf
-      (apply #'string (nreverse buf))
-    ""))
-
-(defun js2-string-to-keyword (s)
-  "Return token for S, a string, if S is a keyword or reserved word.
-Returns a symbol such as 'js2-BREAK, or nil if not keyword/reserved."
-  (or (gethash s js2-keyword-names)
-      (gethash s js2-reserved-word-names)))
-
-(defsubst js2-ts-set-char-token-bounds (token)
-  "Used when next token is one character."
-  (setf (js2-token-beg token) (1- js2-ts-cursor)
-        (js2-token-end token) js2-ts-cursor))
-
-(defsubst js2-ts-return (token type)
-  "Update the `end' and `type' slots of TOKEN,
-then throw `return' with value TYPE."
-  (setf (js2-token-end token) js2-ts-cursor
-        (js2-token-type token) type)
-  (throw 'return type))
-
-(defun js2-x-digit-to-int (c accumulator)
-  "Build up a hex number.
-If C is a hexadecimal digit, return ACCUMULATOR * 16 plus
-corresponding number.  Otherwise return -1."
-  (catch 'return
-    (catch 'check
-      ;; Use 0..9 < A..Z < a..z
-      (cond
-       ((<= c ?9)
-        (cl-decf c ?0)
-        (if (<= 0 c)
-            (throw 'check nil)))
-       ((<= c ?F)
-        (when (<= ?A c)
-          (cl-decf c (- ?A 10))
-          (throw 'check nil)))
-       ((<= c ?f)
-        (when (<= ?a c)
-          (cl-decf c (- ?a 10))
-          (throw 'check nil))))
-      (throw 'return -1))
-    (logior c (lsh accumulator 4))))
-
-(defun js2-get-token (&optional modifier)
-  "If `js2-ti-lookahead' is zero, call scanner to get new token.
-Otherwise, move `js2-ti-tokens-cursor' and return the type of
-next saved token.
-
-This function will not return a newline (js2-EOL) - instead, it
-gobbles newlines until it finds a non-newline token.  Call
-`js2-peek-token-or-eol' when you care about newlines.
-
-This function will also not return a js2-COMMENT.  Instead, it
-records comments found in `js2-scanned-comments'.  If the token
-returned by this function immediately follows a jsdoc comment,
-the token is flagged as such."
-  (if (zerop js2-ti-lookahead)
-      (js2-get-token-internal modifier)
-    (cl-decf js2-ti-lookahead)
-    (setq js2-ti-tokens-cursor (mod (1+ js2-ti-tokens-cursor) js2-ti-ntokens))
-    (let ((tt (js2-current-token-type)))
-      (cl-assert (not (= tt js2-EOL)))
-      tt)))
-
-(defun js2-unget-token ()
-  (cl-assert (< js2-ti-lookahead js2-ti-max-lookahead))
-  (cl-incf js2-ti-lookahead)
-  (setq js2-ti-tokens-cursor (mod (1- js2-ti-tokens-cursor) js2-ti-ntokens)))
-
-(defun js2-get-token-internal (modifier)
-  (let* ((token (js2-get-token-internal-1 modifier)) ; call scanner
-         (tt (js2-token-type token))
-         saw-eol
-         face)
-    ;; process comments
-    (while (or (= tt js2-EOL) (= tt js2-COMMENT))
-      (if (= tt js2-EOL)
-          (setq saw-eol t)
-        (setq saw-eol nil)
-        (when js2-record-comments
-          (js2-record-comment token)))
-      (setq js2-ti-tokens-cursor (mod (1- js2-ti-tokens-cursor) js2-ti-ntokens))
-      (setq token (js2-get-token-internal-1 modifier) ; call scanner again
-            tt (js2-token-type token)))
-
-    (when saw-eol
-      (setf (js2-token-follows-eol-p token) t))
-
-    ;; perform lexical fontification as soon as token is scanned
-    (when js2-parse-ide-mode
-      (cond
-       ((cl-minusp tt)
-        (js2-record-face 'js2-error token))
-       ((setq face (aref js2-kwd-tokens tt))
-        (js2-record-face face token))
-       ((and (= tt js2-NAME)
-             (equal (js2-token-string token) "undefined"))
-        (js2-record-face 'font-lock-constant-face token))))
-    tt))
-
-(defsubst js2-string-to-number (str base)
-  ;; TODO:  Maybe port ScriptRuntime.stringToNumber.
-  (condition-case nil
-      (string-to-number str base)
-    (overflow-error -1)))
-
-(defun js2-get-token-internal-1 (modifier)
-  "Return next JavaScript token type, an int such as js2-RETURN.
-During operation, creates an instance of `js2-token' struct, sets
-its relevant fields and puts it into `js2-ti-tokens'."
-  (let (identifier-start
-        is-unicode-escape-start c
-        contains-escape escape-val str result base
-        look-for-slash continue tt legacy-octal
-        (token (js2-new-token 0)))
-    (setq
-     tt
-     (catch 'return
-       (when (eq modifier 'TEMPLATE_TAIL)
-         (setf (js2-token-beg token) (1- js2-ts-cursor))
-         (throw 'return (js2-get-string-or-template-token ?` token)))
-       (while t
-         ;; Eat whitespace, possibly sensitive to newlines.
-         (setq continue t)
-         (while continue
-           (setq c (js2-get-char))
-           (cond
-            ((eq c js2-EOF_CHAR)
-             (js2-unget-char)
-             (js2-ts-set-char-token-bounds token)
-             (throw 'return js2-EOF))
-            ((eq c ?\n)
-             (js2-ts-set-char-token-bounds token)
-             (setq js2-ts-dirty-line nil)
-             (throw 'return js2-EOL))
-            ((not (js2-js-space-p c))
-             (if (/= c ?-)              ; in case end of HTML comment
-                 (setq js2-ts-dirty-line t))
-             (setq continue nil))))
-         ;; Assume the token will be 1 char - fixed up below.
-         (js2-ts-set-char-token-bounds token)
-         (when (eq c ?@)
-           (throw 'return js2-XMLATTR))
-         ;; identifier/keyword/instanceof?
-         ;; watch out for starting with a <backslash>
-         (cond
-          ((eq c ?\\)
-           (setq c (js2-get-char))
-           (if (eq c ?u)
-               (setq identifier-start t
-                     is-unicode-escape-start t
-                     js2-ts-string-buffer nil)
-             (setq identifier-start nil)
-             (js2-unget-char)
-             (setq c ?\\)))
-          (t
-           (when (setq identifier-start (js2-identifier-start-p c))
-             (setq js2-ts-string-buffer nil)
-             (js2-add-to-string c))))
-         (when identifier-start
-           (setq contains-escape is-unicode-escape-start)
-           (catch 'break
-             (while t
-               (if is-unicode-escape-start
-                   ;; strictly speaking we should probably push-back
-                   ;; all the bad characters if the <backslash>uXXXX
-                   ;; sequence is malformed. But since there isn't a
-                   ;; correct context(is there?) for a bad Unicode
-                   ;; escape sequence in an identifier, we can report
-                   ;; an error here.
-                   (progn
-                     (setq escape-val 0)
-                     (dotimes (_ 4)
-                       (setq c (js2-get-char)
-                             escape-val (js2-x-digit-to-int c escape-val))
-                       ;; Next check takes care of c < 0 and bad escape
-                       (if (cl-minusp escape-val)
-                           (throw 'break nil)))
-                     (if (cl-minusp escape-val)
-                         (js2-report-scan-error "msg.invalid.escape" t))
-                     (js2-add-to-string escape-val)
-                     (setq is-unicode-escape-start nil))
-                 (setq c (js2-get-char))
-                 (cond
-                  ((eq c ?\\)
-                   (setq c (js2-get-char))
-                   (if (eq c ?u)
-                       (setq is-unicode-escape-start t
-                             contains-escape t)
-                     (js2-report-scan-error "msg.illegal.character" t)))
-                  (t
-                   (if (or (eq c js2-EOF_CHAR)
-                           (not (js2-identifier-part-p c)))
-                       (throw 'break nil))
-                   (js2-add-to-string c))))))
-           (js2-unget-char)
-           (setf str (js2-collect-string js2-ts-string-buffer)
-                 (js2-token-end token) js2-ts-cursor)
-           ;; FIXME: Invalid in ES5 and ES6, see
-           ;; https://bugzilla.mozilla.org/show_bug.cgi?id=694360
-           ;; Probably should just drop this conditional.
-           (unless contains-escape
-             ;; OPT we shouldn't have to make a string (object!) to
-             ;; check if it's a keyword.
-             ;; Return the corresponding token if it's a keyword
-             (when (and (not (eq modifier 'KEYWORD_IS_NAME))
-                        (setq result (js2-string-to-keyword str)))
-               (if (and (< js2-language-version 170)
-                        (memq result '(js2-LET js2-YIELD)))
-                   ;; LET and YIELD are tokens only in 1.7 and later
-                   (setq result 'js2-NAME))
-               (when (eq result 'js2-RESERVED)
-                 (setf (js2-token-string token) str))
-               (throw 'return (js2-tt-code result))))
-           ;; If we want to intern these as Rhino does, just use (intern str)
-           (setf (js2-token-string token) str)
-           (throw 'return js2-NAME))    ; end identifier/kwd check
-         ;; is it a number?
-         (when (or (js2-digit-p c)
-                   (and (eq c ?.) (js2-digit-p (js2-peek-char))))
-           (setq js2-ts-string-buffer nil
-                 base 10)
-           (when (eq c ?0)
-             (setq c (js2-get-char))
-             (cond
-              ((or (eq c ?x) (eq c ?X))
-               (setq base 16)
-               (setq c (js2-get-char)))
-              ((and (or (eq c ?b) (eq c ?B))
-                    (>= js2-language-version 200))
-               (setq base 2)
-               (setq c (js2-get-char)))
-              ((and (or (eq c ?o) (eq c ?O))
-                    (>= js2-language-version 200))
-               (setq base 8)
-               (setq legacy-octal nil)
-               (setq c (js2-get-char)))
-              ((js2-digit-p c)
-               (setq base 'maybe-8))
-              (t
-               (js2-add-to-string ?0))))
-           (cond
-            ((eq base 16)
-             (if (> 0 (js2-x-digit-to-int c 0))
-                 (js2-report-scan-error "msg.missing.hex.digits")
-               (while (<= 0 (js2-x-digit-to-int c 0))
-                 (js2-add-to-string c)
-                 (setq c (js2-get-char)))))
-            ((eq base 2)
-             (if (not (memq c '(?0 ?1)))
-                 (js2-report-scan-error "msg.missing.binary.digits")
-               (while (memq c '(?0 ?1))
-                 (js2-add-to-string c)
-                 (setq c (js2-get-char)))))
-            ((eq base 8)
-             (if (or (> ?0 c) (< ?7 c))
-                 (js2-report-scan-error "msg.missing.octal.digits")
-               (while (and (<= ?0 c) (>= ?7 c))
-                 (js2-add-to-string c)
-                 (setq c (js2-get-char)))))
-            (t
-             (while (and (<= ?0 c) (<= c ?9))
-               ;; We permit 08 and 09 as decimal numbers, which
-               ;; makes our behavior a superset of the ECMA
-               ;; numeric grammar.  We might not always be so
-               ;; permissive, so we warn about it.
-               (when (and (eq base 'maybe-8) (>= c ?8))
-                 (js2-report-warning "msg.bad.octal.literal"
-                                     (if (eq c ?8) "8" "9"))
-                 (setq base 10))
-               (js2-add-to-string c)
-               (setq c (js2-get-char)))
-             (when (eq base 'maybe-8)
-               (setq base 8
-                     legacy-octal t))))
-           (when (and (eq base 10) (memq c '(?. ?e ?E)))
-             (when (eq c ?.)
-               (cl-loop do
-                        (js2-add-to-string c)
-                        (setq c (js2-get-char))
-                        while (js2-digit-p c)))
-             (when (memq c '(?e ?E))
-               (js2-add-to-string c)
-               (setq c (js2-get-char))
-               (when (memq c '(?+ ?-))
-                 (js2-add-to-string c)
-                 (setq c (js2-get-char)))
-               (unless (js2-digit-p c)
-                 (js2-report-scan-error "msg.missing.exponent" t))
-               (cl-loop do
-                        (js2-add-to-string c)
-                        (setq c (js2-get-char))
-                        while (js2-digit-p c))))
-           (js2-unget-char)
-           (let ((str (js2-set-string-from-buffer token)))
-             (setf (js2-token-number token) (js2-string-to-number str base)
-                   (js2-token-number-base token) base
-                   (js2-token-number-legacy-octal-p token) (and (= base 8) legacy-octal)))
-           (throw 'return js2-NUMBER))
-         ;; is it a string?
-         (when (or (memq c '(?\" ?\'))
-                   (and (>= js2-language-version 200)
-                        (= c ?`)))
-           (throw 'return
-                  (js2-get-string-or-template-token c token)))
-         (js2-ts-return token
-                        (cl-case c
-                          (?\;
-                           (throw 'return js2-SEMI))
-                          (?\[
-                           (throw 'return js2-LB))
-                          (?\]
-                           (throw 'return js2-RB))
-                          (?{
-                           (throw 'return js2-LC))
-                          (?}
-                           (throw 'return js2-RC))
-                          (?\(
-                           (throw 'return js2-LP))
-                          (?\)
-                           (throw 'return js2-RP))
-                          (?,
-                           (throw 'return js2-COMMA))
-                          (??
-                           (if (js2-match-char ?.)
-                               (throw 'return js2-OPTIONAL-CHAINING)
-                             (throw 'return js2-HOOK)))
-                          (?:
-                           (if (js2-match-char ?:)
-                               js2-COLONCOLON
-                             (throw 'return js2-COLON)))
-                          (?.
-                           (if (js2-match-char ?.)
-                               (if (js2-match-char ?.)
-                                   js2-TRIPLEDOT js2-DOTDOT)
-                             (if (js2-match-char ?\()
-                                 js2-DOTQUERY
-                               (throw 'return js2-DOT))))
-                          (?|
-                           (if (js2-match-char ?|)
-                               (throw 'return js2-OR)
-                             (if (js2-match-char ?=)
-                                 js2-ASSIGN_BITOR
-                               (throw 'return js2-BITOR))))
-                          (?^
-                           (if (js2-match-char ?=)
-                               js2-ASSIGN_BITOR
-                             (throw 'return js2-BITXOR)))
-                          (?&
-                           (if (js2-match-char ?&)
-                               (throw 'return js2-AND)
-                             (if (js2-match-char ?=)
-                                 js2-ASSIGN_BITAND
-                               (throw 'return js2-BITAND))))
-                          (?=
-                           (if (js2-match-char ?=)
-                               (if (js2-match-char ?=)
-                                   js2-SHEQ
-                                 (throw 'return js2-EQ))
-                             (if (js2-match-char ?>)
-                                 (js2-ts-return token js2-ARROW)
-                               (throw 'return js2-ASSIGN))))
-                          (?!
-                           (if (js2-match-char ?=)
-                               (if (js2-match-char ?=)
-                                   js2-SHNE
-                                 js2-NE)
-                             (throw 'return js2-NOT)))
-                          (?<
-                           ;; NB:treat HTML begin-comment as comment-till-eol
-                           (when (js2-match-char ?!)
-                             (when (js2-match-char ?-)
-                               (when (js2-match-char ?-)
-                                 (js2-skip-line)
-                                 (setf (js2-token-comment-type (js2-current-token)) 'html)
-                                 (throw 'return js2-COMMENT)))
-                             (js2-unget-char))
-                           (if (js2-match-char ?<)
-                               (if (js2-match-char ?=)
-                                   js2-ASSIGN_LSH
-                                 js2-LSH)
-                             (if (js2-match-char ?=)
-                                 js2-LE
-                               (throw 'return js2-LT))))
-                          (?>
-                           (if (js2-match-char ?>)
-                               (if (js2-match-char ?>)
-                                   (if (js2-match-char ?=)
-                                       js2-ASSIGN_URSH
-                                     js2-URSH)
-                                 (if (js2-match-char ?=)
-                                     js2-ASSIGN_RSH
-                                   js2-RSH))
-                             (if (js2-match-char ?=)
-                                 js2-GE
-                               (throw 'return js2-GT))))
-                          (?*
-                           (if (js2-match-char ?=)
-                               js2-ASSIGN_MUL
-                             (if (js2-match-char ?*)
-                                 (if (js2-match-char ?=)
-                                     js2-ASSIGN_EXPON
-                                   js2-EXPON)
-                               (throw 'return js2-MUL))))
-                          (?/
-                           ;; is it a // comment?
-                           (when (js2-match-char ?/)
-                             (setf (js2-token-beg token) (- js2-ts-cursor 2))
-                             (js2-skip-line)
-                             (setf (js2-token-comment-type token) 'line)
-                             ;; include newline so highlighting goes to end of
-                             ;; window, if there actually is a newline; if we
-                             ;; hit eof, then implicitly there isn't
-                             (unless js2-ts-hit-eof
-                               (cl-incf (js2-token-end token)))
-                             (throw 'return js2-COMMENT))
-                           ;; is it a /* comment?
-                           (when (js2-match-char ?*)
-                             (setf look-for-slash nil
-                                   (js2-token-beg token) (- js2-ts-cursor 2)
-                                   (js2-token-comment-type token)
-                                   (if (js2-match-char ?*)
-                                       (progn
-                                         (setq look-for-slash t)
-                                         'jsdoc)
-                                     'block))
-                             (while t
-                               (setq c (js2-get-char))
-                               (cond
-                                ((eq c js2-EOF_CHAR)
-                                 (setf (js2-token-end token) (1- js2-ts-cursor))
-                                 (js2-report-error "msg.unterminated.comment")
-                                 (throw 'return js2-COMMENT))
-                                ((eq c ?*)
-                                 (setq look-for-slash t))
-                                ((eq c ?/)
-                                 (if look-for-slash
-                                     (js2-ts-return token js2-COMMENT)))
-                                (t
-                                 (setf look-for-slash nil
-                                       (js2-token-end token) js2-ts-cursor)))))
-                           (if (js2-match-char ?=)
-                               js2-ASSIGN_DIV
-                             (throw 'return js2-DIV)))
-                          (?#
-                           (when js2-skip-preprocessor-directives
-                             (js2-skip-line)
-                             (setf (js2-token-comment-type token) 'preprocessor
-                                   (js2-token-end token) js2-ts-cursor)
-                             (throw 'return js2-COMMENT))
-                           (throw 'return js2-ERROR))
-                          (?%
-                           (if (js2-match-char ?=)
-                               js2-ASSIGN_MOD
-                             (throw 'return js2-MOD)))
-                          (?~
-                           (throw 'return js2-BITNOT))
-                          (?+
-                           (if (js2-match-char ?=)
-                               js2-ASSIGN_ADD
-                             (if (js2-match-char ?+)
-                                 js2-INC
-                               (throw 'return js2-ADD))))
-                          (?-
-                           (cond
-                            ((js2-match-char ?=)
-                             (setq c js2-ASSIGN_SUB))
-                            ((js2-match-char ?-)
-                             (unless js2-ts-dirty-line
-                               ;; treat HTML end-comment after possible whitespace
-                               ;; after line start as comment-until-eol
-                               (when (js2-match-char ?>)
-                                 (js2-skip-line)
-                                 (setf (js2-token-comment-type (js2-current-token)) 'html)
-                                 (throw 'return js2-COMMENT)))
-                             (setq c js2-DEC))
-                            (t
-                             (setq c js2-SUB)))
-                           (setq js2-ts-dirty-line t)
-                           c)
-                          (otherwise
-                           (js2-report-scan-error "msg.illegal.character")))))))
-    (setf (js2-token-type token) tt)
-    token))
-
-(defun js2-get-string-or-template-token (quote-char token)
-  ;; We attempt to accumulate a string the fast way, by
-  ;; building it directly out of the reader.  But if there
-  ;; are any escaped characters in the string, we revert to
-  ;; building it out of a string buffer.
-  (let ((c (js2-get-char))
-        js2-ts-string-buffer
-        nc c1 val escape-val)
-    (catch 'break
-      (while (/= c quote-char)
-        (catch 'continue
-          (when (eq c js2-EOF_CHAR)
-            (js2-unget-char)
-            (js2-report-error "msg.unterminated.string.lit")
-            (throw 'break nil))
-          (when (and (eq c ?\n) (not (eq quote-char ?`)))
-            (js2-unget-char)
-            (js2-report-error "msg.unterminated.string.lit")
-            (throw 'break nil))
-          (when (eq c ?\\)
-            ;; We've hit an escaped character
-            (setq c (js2-get-char))
-            (cl-case c
-              (?b (setq c ?\b))
-              (?f (setq c ?\f))
-              (?n (setq c ?\n))
-              (?r (setq c ?\r))
-              (?t (setq c ?\t))
-              (?v (setq c ?\v))
-              (?u
-               (setq c1 (js2-read-unicode-escape))
-               (if js2-parse-ide-mode
-                   (if c1
-                       (progn
-                         ;; just copy the string in IDE-mode
-                         (js2-add-to-string ?\\)
-                         (js2-add-to-string ?u)
-                         (dotimes (_ 3)
-                           (js2-add-to-string (js2-get-char)))
-                         (setq c (js2-get-char))) ; added at end of loop
-                     ;; flag it as an invalid escape
-                     (js2-report-warning "msg.invalid.escape"
-                                         nil (- js2-ts-cursor 2) 6))
-                 ;; Get 4 hex digits; if the u escape is not
-                 ;; followed by 4 hex digits, use 'u' + the
-                 ;; literal character sequence that follows.
-                 (js2-add-to-string ?u)
-                 (setq escape-val 0)
-                 (dotimes (_ 4)
-                   (setq c (js2-get-char)
-                         escape-val (js2-x-digit-to-int c escape-val))
-                   (if (cl-minusp escape-val)
-                       (throw 'continue nil))
-                   (js2-add-to-string c))
-                 ;; prepare for replace of stored 'u' sequence by escape value
-                 (setq js2-ts-string-buffer (nthcdr 5 js2-ts-string-buffer)
-                       c escape-val)))
-              (?x
-               ;; Get 2 hex digits, defaulting to 'x'+literal
-               ;; sequence, as above.
-               (setq c (js2-get-char)
-                     escape-val (js2-x-digit-to-int c 0))
-               (if (cl-minusp escape-val)
-                   (progn
-                     (js2-add-to-string ?x)
-                     (throw 'continue nil))
-                 (setq c1 c
-                       c (js2-get-char)
-                       escape-val (js2-x-digit-to-int c escape-val))
-                 (if (cl-minusp escape-val)
-                     (progn
-                       (js2-add-to-string ?x)
-                       (js2-add-to-string c1)
-                       (throw 'continue nil))
-                   ;; got 2 hex digits
-                   (setq c escape-val))))
-              (?\n
-               ;; Remove line terminator after escape to follow
-               ;; SpiderMonkey and C/C++
-               (setq c (js2-get-char))
-               (throw 'continue nil))
-              (t
-               (when (and (<= ?0 c) (< c ?8))
-                 (setq val (- c ?0)
-                       c (js2-get-char))
-                 (when (and (<= ?0 c) (< c ?8))
-                   (setq val (- (+ (* 8 val) c) ?0)
-                         c (js2-get-char))
-                   (when (and (<= ?0 c)
-                              (< c ?8)
-                              (< val #o37))
-                     ;; c is 3rd char of octal sequence only
-                     ;; if the resulting val <= 0377
-                     (setq val (- (+ (* 8 val) c) ?0)
-                           c (js2-get-char))))
-                 (js2-unget-char)
-                 (setq c val)))))
-          (when (and (eq quote-char ?`) (eq c ?$))
-            (when (eq (setq nc (js2-get-char)) ?\{)
-              (throw 'break nil))
-            (js2-unget-char))
-          (js2-add-to-string c)
-          (setq c (js2-get-char)))))
-    (js2-set-string-from-buffer token)
-    (if (not (eq quote-char ?`))
-        js2-STRING
-      (if (and (eq c ?$) (eq nc ?\{))
-          js2-TEMPLATE_HEAD
-        js2-NO_SUBS_TEMPLATE))))
-
-(defun js2-read-regexp (start-tt start-pos)
-  "Called by parser when it gets / or /= in literal context."
-  (let (c err
-        in-class  ; inside a '[' .. ']' character-class
-        flags
-        (continue t)
-        (token (js2-new-token 0)))
-    (when js2-mode-change-syntax-p
-      (js2-record-text-property start-pos (1+ start-pos)
-                                'syntax-table (string-to-syntax "\"/")))
-    (setq js2-ts-string-buffer nil)
-    (if (eq start-tt js2-ASSIGN_DIV)
-        ;; mis-scanned /=
-        (js2-add-to-string ?=)
-      (if (not (eq start-tt js2-DIV))
-          (error "failed assertion")))
-    (while (and (not err)
-                (or (/= (setq c (js2-get-char)) ?/)
-                    in-class))
-      (cond
-       ((or (= c ?\n)
-            (= c js2-EOF_CHAR))
-        (setf (js2-token-end token) (1- js2-ts-cursor)
-              err t
-              (js2-token-string token) (js2-collect-string js2-ts-string-buffer))
-        (js2-report-error "msg.unterminated.re.lit"))
-       (t (cond
-           ((= c ?\\)
-            (js2-add-to-string c)
-            (setq c (js2-get-char)))
-           ((= c ?\[)
-            (setq in-class t))
-           ((= c ?\])
-            (setq in-class nil)))
-          (js2-add-to-string c))))
-    (unless err
-      (when js2-mode-change-syntax-p
-        (js2-record-text-property (1- js2-ts-cursor) js2-ts-cursor
-                                  'syntax-table (string-to-syntax "\"/")))
-      (while continue
-        (cond
-         ((js2-match-char ?g)
-          (push ?g flags))
-         ((js2-match-char ?i)
-          (push ?i flags))
-         ((js2-match-char ?m)
-          (push ?m flags))
-         ((and (js2-match-char ?u)
-               (>= js2-language-version 200))
-          (push ?u flags))
-         ((and (js2-match-char ?y)
-               (>= js2-language-version 200))
-          (push ?y flags))
-         (t
-          (setq continue nil))))
-      (if (js2-alpha-p (js2-peek-char))
-          (js2-report-scan-error "msg.invalid.re.flag" t
-                                 js2-ts-cursor 1))
-      (js2-set-string-from-buffer token))
-    (js2-collect-string flags)))
-
-(defun js2-get-first-xml-token ()
-  (setq js2-ts-xml-open-tags-count 0
-        js2-ts-is-xml-attribute nil
-        js2-ts-xml-is-tag-content nil)
-  (js2-unget-char)
-  (js2-get-next-xml-token))
-
-(defun js2-xml-discard-string (token)
-  "Throw away the string in progress and flag an XML parse error."
-  (setf js2-ts-string-buffer nil
-        (js2-token-string token) nil)
-  (js2-report-scan-error "msg.XML.bad.form" t))
-
-(defun js2-get-next-xml-token ()
-  (setq js2-ts-string-buffer nil)  ; for recording the XML
-  (let ((token (js2-new-token 0))
-        c result)
-    (setq result
-          (catch 'return
-            (while t
-              (setq c (js2-get-char))
-              (cond
-               ((= c js2-EOF_CHAR)
-                (throw 'return js2-ERROR))
-               (js2-ts-xml-is-tag-content
-                (cl-case c
-                  (?>
-                   (js2-add-to-string c)
-                   (setq js2-ts-xml-is-tag-content nil
-                         js2-ts-is-xml-attribute nil))
-                  (?/
-                   (js2-add-to-string c)
-                   (when (eq ?> (js2-peek-char))
-                     (setq c (js2-get-char))
-                     (js2-add-to-string c)
-                     (setq js2-ts-xml-is-tag-content nil)
-                     (cl-decf js2-ts-xml-open-tags-count)))
-                  (?{
-                   (js2-unget-char)
-                   (js2-set-string-from-buffer token)
-                   (throw 'return js2-XML))
-                  ((?\' ?\")
-                   (js2-add-to-string c)
-                   (unless (js2-read-quoted-string c token)
-                     (throw 'return js2-ERROR)))
-                  (?=
-                   (js2-add-to-string c)
-                   (setq js2-ts-is-xml-attribute t))
-                  ((? ?\t ?\r ?\n)
-                   (js2-add-to-string c))
-                  (t
-                   (js2-add-to-string c)
-                   (setq js2-ts-is-xml-attribute nil)))
-                (when (and (not js2-ts-xml-is-tag-content)
-                           (zerop js2-ts-xml-open-tags-count))
-                  (js2-set-string-from-buffer token)
-                  (throw 'return js2-XMLEND)))
-               (t
-                ;; else not tag content
-                (cl-case c
-                  (?<
-                   (js2-add-to-string c)
-                   (setq c (js2-peek-char))
-                   (cl-case c
-                     (?!
-                      (setq c (js2-get-char)) ;; skip !
-                      (js2-add-to-string c)
-                      (setq c (js2-peek-char))
-                      (cl-case c
-                        (?-
-                         (setq c (js2-get-char)) ;; skip -
-                         (js2-add-to-string c)
-                         (if (eq c ?-)
-                             (progn
-                               (js2-add-to-string c)
-                               (unless (js2-read-xml-comment token)
-                                 (throw 'return js2-ERROR)))
-                           (js2-xml-discard-string token)
-                           (throw 'return js2-ERROR)))
-                        (?\[
-                         (setq c (js2-get-char)) ;; skip [
-                         (js2-add-to-string c)
-                         (if (and (= (js2-get-char) ?C)
-                                  (= (js2-get-char) ?D)
-                                  (= (js2-get-char) ?A)
-                                  (= (js2-get-char) ?T)
-                                  (= (js2-get-char) ?A)
-                                  (= (js2-get-char) ?\[))
-                             (progn
-                               (js2-add-to-string ?C)
-                               (js2-add-to-string ?D)
-                               (js2-add-to-string ?A)
-                               (js2-add-to-string ?T)
-                               (js2-add-to-string ?A)
-                               (js2-add-to-string ?\[)
-                               (unless (js2-read-cdata token)
-                                 (throw 'return js2-ERROR)))
-                           (js2-xml-discard-string token)
-                           (throw 'return js2-ERROR)))
-                        (t
-                         (unless (js2-read-entity token)
-                           (throw 'return js2-ERROR))))
-                      ;; Allow bare CDATA section, e.g.:
-                      ;;   let xml = <![CDATA[ foo bar baz ]]>;
-                      (when (zerop js2-ts-xml-open-tags-count)
-                        (throw 'return js2-XMLEND)))
-                     (??
-                      (setq c (js2-get-char)) ;; skip ?
-                      (js2-add-to-string c)
-                      (unless (js2-read-PI token)
-                        (throw 'return js2-ERROR)))
-                     (?/
-                      ;; end tag
-                      (setq c (js2-get-char)) ;; skip /
-                      (js2-add-to-string c)
-                      (when (zerop js2-ts-xml-open-tags-count)
-                        (js2-xml-discard-string token)
-                        (throw 'return js2-ERROR))
-                      (setq js2-ts-xml-is-tag-content t)
-                      (cl-decf js2-ts-xml-open-tags-count))
-                     (t
-                      ;; start tag
-                      (setq js2-ts-xml-is-tag-content t)
-                      (cl-incf js2-ts-xml-open-tags-count))))
-                  (?{
-                   (js2-unget-char)
-                   (js2-set-string-from-buffer token)
-                   (throw 'return js2-XML))
-                  (t
-                   (js2-add-to-string c))))))))
-    (setf (js2-token-end token) js2-ts-cursor)
-    (setf (js2-token-type token) result)
-    result))
-
-(defun js2-read-quoted-string (quote token)
-  (let (c)
-    (catch 'return
-      (while (/= (setq c (js2-get-char)) js2-EOF_CHAR)
-        (js2-add-to-string c)
-        (if (eq c quote)
-            (throw 'return t)))
-      (js2-xml-discard-string token)  ;; throw away string in progress
-      nil)))
-
-(defun js2-read-xml-comment (token)
-  (let ((c (js2-get-char)))
-    (catch 'return
-      (while (/= c js2-EOF_CHAR)
-        (catch 'continue
-          (js2-add-to-string c)
-          (when (and (eq c ?-) (eq ?- (js2-peek-char)))
-            (setq c (js2-get-char))
-            (js2-add-to-string c)
-            (if (eq (js2-peek-char) ?>)
-                (progn
-                  (setq c (js2-get-char)) ;; skip >
-                  (js2-add-to-string c)
-                  (throw 'return t))
-              (throw 'continue nil)))
-          (setq c (js2-get-char))))
-      (js2-xml-discard-string token)
-      nil)))
-
-(defun js2-read-cdata (token)
-  (let ((c (js2-get-char)))
-    (catch 'return
-      (while (/= c js2-EOF_CHAR)
-        (catch 'continue
-          (js2-add-to-string c)
-          (when (and (eq c ?\]) (eq (js2-peek-char) ?\]))
-            (setq c (js2-get-char))
-            (js2-add-to-string c)
-            (if (eq (js2-peek-char) ?>)
-                (progn
-                  (setq c (js2-get-char)) ;; Skip >
-                  (js2-add-to-string c)
-                  (throw 'return t))
-              (throw 'continue nil)))
-          (setq c (js2-get-char))))
-      (js2-xml-discard-string token)
-      nil)))
-
-(defun js2-read-entity (token)
-  (let ((decl-tags 1)
-        c)
-    (catch 'return
-      (while (/= js2-EOF_CHAR (setq c (js2-get-char)))
-        (js2-add-to-string c)
-        (cl-case c
-          (?<
-           (cl-incf decl-tags))
-          (?>
-           (cl-decf decl-tags)
-           (if (zerop decl-tags)
-               (throw 'return t)))))
-      (js2-xml-discard-string token)
-      nil)))
-
-(defun js2-read-PI (token)
-  "Scan an XML processing instruction."
-  (let (c)
-    (catch 'return
-      (while (/= js2-EOF_CHAR (setq c (js2-get-char)))
-        (js2-add-to-string c)
-        (when (and (eq c ??) (eq (js2-peek-char) ?>))
-          (setq c (js2-get-char))  ;; Skip >
-          (js2-add-to-string c)
-          (throw 'return t)))
-      (js2-xml-discard-string token)
-      nil)))
-
-;;; Highlighting
-
-(defun js2-set-face (beg end face &optional record)
-  "Fontify a region.  If RECORD is non-nil, record for later."
-  (when (cl-plusp js2-highlight-level)
-    (setq beg (min (point-max) beg)
-          beg (max (point-min) beg)
-          end (min (point-max) end)
-          end (max (point-min) end))
-    (if record
-        (push (list beg end face) js2-mode-fontifications)
-      (put-text-property beg end 'font-lock-face face))))
-
-(defsubst js2-clear-face (beg end)
-  (remove-text-properties beg end '(font-lock-face nil
-                                    help-echo nil
-                                    point-entered nil
-                                    cursor-sensor-functions nil
-                                    c-in-sws nil)))
-
-(defconst js2-ecma-global-props
-  (concat "^"
-          (regexp-opt
-           '("Infinity" "NaN" "undefined" "arguments") t)
-          "$")
-  "Value properties of the Ecma-262 Global Object.
-Shown at or above `js2-highlight-level' 2.")
-
-;; might want to add the name "arguments" to this list?
-(defconst js2-ecma-object-props
-  (concat "^"
-          (regexp-opt
-           '("prototype" "__proto__" "__parent__") t)
-          "$")
-  "Value properties of the Ecma-262 Object constructor.
-Shown at or above `js2-highlight-level' 2.")
-
-(defconst js2-ecma-global-funcs
-  (concat
-   "^"
-   (regexp-opt
-    '("decodeURI" "decodeURIComponent" "encodeURI" "encodeURIComponent"
-      "eval" "isFinite" "isNaN" "parseFloat" "parseInt") t)
-   "$")
-  "Function properties of the Ecma-262 Global object.
-Shown at or above `js2-highlight-level' 2.")
-
-(defconst js2-ecma-number-props
-  (concat "^"
-          (regexp-opt '("MAX_VALUE" "MIN_VALUE" "NaN"
-                        "NEGATIVE_INFINITY"
-                        "POSITIVE_INFINITY") t)
-          "$")
-  "Properties of the Ecma-262 Number constructor.
-Shown at or above `js2-highlight-level' 2.")
-
-(defconst js2-ecma-date-props "^\\(parse\\|UTC\\)$"
-  "Properties of the Ecma-262 Date constructor.
-Shown at or above `js2-highlight-level' 2.")
-
-(defconst js2-ecma-math-props
-  (concat "^"
-          (regexp-opt
-           '("E" "LN10" "LN2" "LOG2E" "LOG10E" "PI" "SQRT1_2" "SQRT2")
-           t)
-          "$")
-  "Properties of the Ecma-262 Math object.
-Shown at or above `js2-highlight-level' 2.")
-
-(defconst js2-ecma-math-funcs
-  (concat "^"
-          (regexp-opt
-           '("abs" "acos" "asin" "atan" "atan2" "ceil" "cos" "exp" "floor"
-             "log" "max" "min" "pow" "random" "round" "sin" "sqrt" "tan") t)
-          "$")
-  "Function properties of the Ecma-262 Math object.
-Shown at or above `js2-highlight-level' 2.")
-
-(defconst js2-ecma-function-props
-  (concat
-   "^"
-   (regexp-opt
-    '(;; properties of the Object prototype object
-      "hasOwnProperty" "isPrototypeOf" "propertyIsEnumerable"
-      "toLocaleString" "toString" "valueOf"
-      ;; properties of the Function prototype object
-      "apply" "call"
-      ;; properties of the Array prototype object
-      "concat" "join" "pop" "push" "reverse" "shift" "slice" "sort"
-      "splice" "unshift"
-      ;; properties of the String prototype object
-      "charAt" "charCodeAt" "fromCharCode" "indexOf" "lastIndexOf"
-      "localeCompare" "match" "replace" "search" "split" "substring"
-      "toLocaleLowerCase" "toLocaleUpperCase" "toLowerCase"
-      "toUpperCase"
-      ;; properties of the Number prototype object
-      "toExponential" "toFixed" "toPrecision"
-      ;; properties of the Date prototype object
-      "getDate" "getDay" "getFullYear" "getHours" "getMilliseconds"
-      "getMinutes" "getMonth" "getSeconds" "getTime"
-      "getTimezoneOffset" "getUTCDate" "getUTCDay" "getUTCFullYear"
-      "getUTCHours" "getUTCMilliseconds" "getUTCMinutes" "getUTCMonth"
-      "getUTCSeconds" "setDate" "setFullYear" "setHours"
-      "setMilliseconds" "setMinutes" "setMonth" "setSeconds" "setTime"
-      "setUTCDate" "setUTCFullYear" "setUTCHours" "setUTCMilliseconds"
-      "setUTCMinutes" "setUTCMonth" "setUTCSeconds" "toDateString"
-      "toLocaleDateString" "toLocaleString" "toLocaleTimeString"
-      "toTimeString" "toUTCString"
-      ;; properties of the RegExp prototype object
-      "exec" "test"
-      ;; properties of the JSON prototype object
-      "parse" "stringify"
-      ;; SpiderMonkey/Rhino extensions, versions 1.5+
-      "toSource" "__defineGetter__" "__defineSetter__"
-      "__lookupGetter__" "__lookupSetter__" "__noSuchMethod__"
-      "every" "filter" "forEach" "lastIndexOf" "map" "some")
-    t)
-   "$")
-  "Built-in functions defined by Ecma-262 and SpiderMonkey extensions.
-Shown at or above `js2-highlight-level' 3.")
-
-(defun js2-parse-highlight-prop-get (parent target prop call-p)
-  (let ((target-name (and target
-                          (js2-name-node-p target)
-                          (js2-name-node-name target)))
-        (prop-name (if prop (js2-name-node-name prop)))
-        (level2 (>= js2-highlight-level 2))
-        (level3 (>= js2-highlight-level 3)))
-    (when level2
-      (let ((face
-             (if call-p
-                 (cond
-                  ((and target prop)
-                   (cond
-                    ((and level3 (string-match js2-ecma-function-props prop-name))
-                     'font-lock-builtin-face)
-                    ((and target-name prop)
-                     (cond
-                      ((string= target-name "Date")
-                       (if (string-match js2-ecma-date-props prop-name)
-                           'font-lock-builtin-face))
-                      ((string= target-name "Math")
-                       (if (string-match js2-ecma-math-funcs prop-name)
-                           'font-lock-builtin-face))))))
-                  (prop
-                   (if (string-match js2-ecma-global-funcs prop-name)
-                       'font-lock-builtin-face)))
-               (cond
-                ((and target prop)
-                 (cond
-                  ((string= target-name "Number")
-                   (if (string-match js2-ecma-number-props prop-name)
-                       'font-lock-constant-face))
-                  ((string= target-name "Math")
-                   (if (string-match js2-ecma-math-props prop-name)
-                       'font-lock-constant-face))))
-                (prop
-                 (if (string-match js2-ecma-object-props prop-name)
-                     'font-lock-constant-face))))))
-        (when (and (not face) target (not call-p) prop-name)
-          (setq face 'js2-object-property-access))
-        (when face
-          (let ((pos (+ (js2-node-pos parent)  ; absolute
-                        (js2-node-pos prop)))) ; relative
-            (js2-set-face pos
-                          (+ pos (js2-node-len prop))
-                          face 'record)))))))
-
-(defun js2-parse-highlight-member-expr-node (node)
-  "Perform syntax highlighting of EcmaScript built-in properties.
-The variable `js2-highlight-level' governs this highlighting."
-  (let (face target prop name pos end parent call-p callee)
-    (cond
-     ;; case 1:  simple name, e.g. foo
-     ((js2-name-node-p node)
-      (setq name (js2-name-node-name node))
-      ;; possible for name to be nil in rare cases - saw it when
-      ;; running js2-mode on an elisp buffer.  Might as well try to
-      ;; make it so js2-mode never barfs.
-      (when name
-        (setq face (if (string-match js2-ecma-global-props name)
-                       'font-lock-constant-face))
-        (when face
-          (setq pos (js2-node-pos node)
-                end (+ pos (js2-node-len node)))
-          (js2-set-face pos end face 'record))))
-     ;; case 2:  property access or function call
-     ((or (js2-prop-get-node-p node)
-          ;; highlight function call if expr is a prop-get node
-          ;; or a plain name (i.e. unqualified function call)
-          (and (setq call-p (js2-call-node-p node))
-               (setq callee (js2-call-node-target node)) ; separate setq!
-               (or (js2-prop-get-node-p callee)
-                   (js2-name-node-p callee))))
-      (setq parent node
-            node (if call-p callee node))
-      (if (and call-p (js2-name-node-p callee))
-          (setq prop callee)
-        (setq target (js2-prop-get-node-left node)
-              prop (js2-prop-get-node-right node)))
-      (cond
-       ((js2-name-node-p prop)
-        ;; case 2(a&c):  simple or complex target, simple name, e.g. x[y].bar
-        (js2-parse-highlight-prop-get parent target prop call-p))
-       ((js2-name-node-p target)
-        ;; case 2b:  simple target, complex name, e.g. foo.x[y]
-        (js2-parse-highlight-prop-get parent target nil call-p)))))))
-
-(defun js2-parse-highlight-member-expr-fn-name (expr)
-  "Highlight the `baz' in function foo.bar.baz(args) {...}.
-This is experimental Rhino syntax.  EXPR is the foo.bar.baz member expr.
-We currently only handle the case where the last component is a prop-get
-of a simple name.  Called before EXPR has a parent node."
-  (let (pos
-        (name (and (js2-prop-get-node-p expr)
-                   (js2-prop-get-node-right expr))))
-    (when (js2-name-node-p name)
-      (js2-set-face (setq pos (+ (js2-node-pos expr)  ; parent is absolute
-                                 (js2-node-pos name)))
-                    (+ pos (js2-node-len name))
-                    'font-lock-function-name-face
-                    'record))))
-
-;; source:  http://jsdoc.sourceforge.net/
-;; Note - this syntax is for Google's enhanced jsdoc parser that
-;; allows type specifications, and needs work before entering the wild.
-
-(defconst js2-jsdoc-param-tag-regexp
-  (concat "^\\s-*\\*+\\s-*\\(@"
-          (regexp-opt '("param" "arg" "argument" "prop" "property" "typedef"))
-          "\\)"
-          "\\s-*\\({[^}]+}\\)?"         ; optional type
-          "\\s-*\\[?\\([[:alnum:]_$\.]+\\)?\\]?"  ; name
-          "\\_>")
-  "Matches jsdoc tags with optional type and optional param name.")
-
-(defconst js2-jsdoc-typed-tag-regexp
-  (concat "^\\s-*\\*+\\s-*\\(@\\(?:"
-          (regexp-opt
-           '("enum"
-             "extends"
-             "field"
-             "id"
-             "implements"
-             "lends"
-             "mods"
-             "requires"
-             "return"
-             "returns"
-             "yield"
-             "yields"
-             "type"
-             "throw"
-             "throws"))
-          "\\)\\)\\s-*\\({[^}]+}\\)?")
-  "Matches jsdoc tags with optional type.")
-
-(defconst js2-jsdoc-arg-tag-regexp
-  (concat "^\\s-*\\*+\\s-*\\(@\\(?:"
-          (regexp-opt
-           '("alias"
-             "augments"
-             "borrows"
-             "callback"
-             "bug"
-             "base"
-             "config"
-             "default"
-             "define"
-             "exception"
-             "func"
-             "function"
-             "member"
-             "memberOf"
-             "method"
-             "module"
-             "name"
-             "namespace"
-             "since"
-             "suppress"
-             "this"
-             "throws"
-             "version"))
-          "\\)\\)\\s-+\\([^ \t\n]+\\)")
-  "Matches jsdoc tags with a single argument.")
-
-(defconst js2-jsdoc-empty-tag-regexp
-  (concat "^\\s-*\\*+\\s-*\\(@\\(?:"
-          (regexp-opt
-           '("abstract"
-             "addon"
-             "author"
-             "class"
-             "const"
-             "constant"
-             "constructor"
-             "constructs"
-             "deprecated"
-             "desc"
-             "description"
-             "event"
-             "example"
-             "exec"
-             "export"
-             "fileoverview"
-             "final"
-             "func"
-             "function"
-             "hidden"
-             "ignore"
-             "implicitCast"
-             "inheritDoc"
-             "inner"
-             "interface"
-             "license"
-             "method"
-             "noalias"
-             "noshadow"
-             "notypecheck"
-             "override"
-             "owner"
-             "preserve"
-             "preserveTry"
-             "private"
-             "protected"
-             "public"
-             "static"
-             "supported"
-             "virtual"
-             ))
-          "\\)\\)\\s-*")
-  "Matches empty jsdoc tags.")
-
-(defconst js2-jsdoc-link-tag-regexp
-  "{\\(@\\(?:link\\|code\\)\\)\\s-+\\([^#}\n]+\\)\\(#.+\\)?}"
-  "Matches a jsdoc link or code tag.")
-
-(defconst js2-jsdoc-see-tag-regexp
-  "^\\s-*\\*+\\s-*\\(@see\\)\\s-+\\([^#}\n]+\\)\\(#.+\\)?"
-  "Matches a jsdoc @see tag.")
-
-(defconst js2-jsdoc-html-tag-regexp
-  "\\(</?\\)\\([[:alpha:]]+\\)\\s-*\\(/?>\\)"
-  "Matches a simple (no attributes) html start- or end-tag.")
-
-(defun js2-jsdoc-highlight-helper ()
-  (js2-set-face (match-beginning 1)
-                (match-end 1)
-                'js2-jsdoc-tag)
-  (if (match-beginning 2)
-      (if (save-excursion
-            (goto-char (match-beginning 2))
-            (= (char-after) ?{))
-          (js2-set-face (1+ (match-beginning 2))
-                        (1- (match-end 2))
-                        'js2-jsdoc-type)
-        (js2-set-face (match-beginning 2)
-                      (match-end 2)
-                      'js2-jsdoc-value)))
-  (if (match-beginning 3)
-      (js2-set-face (match-beginning 3)
-                    (match-end 3)
-                    'js2-jsdoc-value)))
-
-(defun js2-highlight-jsdoc (ast)
-  "Highlight doc comment tags."
-  (let ((comments (js2-ast-root-comments ast))
-        beg end)
-    (save-excursion
-      (dolist (node comments)
-        (when (eq (js2-comment-node-format node) 'jsdoc)
-          ;; Slice off the leading /* and trailing */ in case there
-          ;; are tags on the first line
-          (setq beg (+ 2 (js2-node-abs-pos node))
-                end (+ beg -4 (js2-node-len node)))
-          (save-restriction
-            (narrow-to-region beg end)
-            (dolist (re (list js2-jsdoc-param-tag-regexp
-                              js2-jsdoc-typed-tag-regexp
-                              js2-jsdoc-arg-tag-regexp
-                              js2-jsdoc-link-tag-regexp
-                              js2-jsdoc-see-tag-regexp
-                              js2-jsdoc-empty-tag-regexp))
-              (goto-char beg)
-              (while (re-search-forward re nil t)
-                (js2-jsdoc-highlight-helper)))
-            ;; simple highlighting for html tags
-            (goto-char beg)
-            (while (re-search-forward js2-jsdoc-html-tag-regexp nil t)
-              (js2-set-face (match-beginning 1)
-                            (match-end 1)
-                            'js2-jsdoc-html-tag-delimiter)
-              (js2-set-face (match-beginning 2)
-                            (match-end 2)
-                            'js2-jsdoc-html-tag-name)
-              (js2-set-face (match-beginning 3)
-                            (match-end 3)
-                            'js2-jsdoc-html-tag-delimiter))))))))
-
-(defun js2-highlight-assign-targets (_node left right)
-  "Highlight function properties and external variables."
-  (let (leftpos name)
-    ;; highlight vars and props assigned function values
-    (when (or (js2-function-node-p right)
-              (js2-class-node-p right))
-      (cond
-       ;; var foo = function() {...}
-       ((js2-name-node-p left)
-        (setq name left))
-       ;; foo.bar.baz = function() {...}
-       ((and (js2-prop-get-node-p left)
-             (js2-name-node-p (js2-prop-get-node-right left)))
-        (setq name (js2-prop-get-node-right left))))
-      (when name
-        (js2-set-face (setq leftpos (js2-node-abs-pos name))
-                      (+ leftpos (js2-node-len name))
-                      'font-lock-function-name-face
-                      'record)))))
-
-(defun js2-record-name-node (node)
-  "Saves NODE to `js2-recorded-identifiers' to check for undeclared variables
-later. NODE must be a name node."
-  (let ((leftpos (js2-node-abs-pos node)))
-    (push (list node js2-current-scope
-                leftpos
-                (+ leftpos (js2-node-len node)))
-          js2-recorded-identifiers)))
-
-(defun js2-highlight-undeclared-vars ()
-  "After entire parse is finished, look for undeclared variable references.
-We have to wait until entire buffer is parsed, since JavaScript permits var
-declarations to occur after they're used.
-
-Some identifiers may be assumed to be externally defined.
-These externs are not highlighted, even if there is no declaration
-for them in the source code (in the current file).
-
-The list of externs consists of the following:
-
-  - `js2-ecma262-externs' for basic names from the ECMAScript language standard.
-  - Depending on the buffer-local variables `js2-include-*-externs'
-    the corresponding `js2-*-externs' to add names for certain environments
-    like the browser, Node or Rhino.
-  - Two customizable lists `js2-global-externs' and `js2-additional-externs',
-    the latter of which should be set per-buffer.
-
-See especially `js2-additional-externs' for further details about externs."
-  (let ((default-externs
-          (append js2-ecma-262-externs
-                  (if (and js2-include-browser-externs
-                           (>= js2-language-version 200)) js2-harmony-externs)
-                  (if js2-include-rhino-externs js2-rhino-externs)
-                  (if js2-include-node-externs js2-node-externs)
-                  (if (or js2-include-browser-externs js2-include-node-externs)
-                      js2-typed-array-externs)
-                  (if js2-include-browser-externs js2-browser-externs)))
-        name)
-    (dolist (entry js2-recorded-identifiers)
-      (cl-destructuring-bind (name-node scope pos end) entry
-        (setq name (js2-name-node-name name-node))
-        (unless (or (member name js2-global-externs)
-                    (member name default-externs)
-                    (member name js2-additional-externs)
-                    (js2-get-defining-scope scope name pos))
-          (js2-report-warning "msg.undeclared.variable" name pos (- end pos)
-                              'js2-external-variable))))))
-
-(defun js2--add-or-update-symbol (symbol inition used vars)
-  "Add or update SYMBOL entry in VARS, an hash table.
-SYMBOL is a js2-name-node, INITION either nil, t, or ?P,
-respectively meaning that SYMBOL is a mere declaration, an
-assignment or a function parameter; when USED is t, the symbol
-node is assumed to be an usage and thus added to the list stored
-in the cdr of the entry.
-"
-  (let* ((nm (js2-name-node-name symbol))
-         (es (js2-node-get-enclosing-scope symbol))
-         (ds (js2-get-defining-scope es nm)))
-    (when (and ds (not (equal nm "arguments")))
-      (let* ((sym (js2-scope-get-symbol ds nm))
-             (var (gethash sym vars))
-             (err-var-p (js2-catch-node-p ds)))
-        (unless inition
-          (setq inition err-var-p))
-        (if var
-            (progn
-              (when (and inition (not (equal (car var) ?P)))
-                (setcar var inition))
-              (when (and used (not (memq symbol (cdr var))))
-                (push symbol (cdr var))))
-          ;; do not consider the declaration of catch parameter as an usage
-          (when (and err-var-p used)
-            (setq used nil))
-          (puthash sym (cons inition (if used (list symbol))) vars))))))
-
-(defun js2--collect-target-symbols (node strict)
-  "Collect the `js-name-node' symbols declared in NODE and return a list of them.
-NODE is either `js2-array-node', `js2-object-node', or `js2-name-node'.
-When STRICT, signal an error if NODE is not one of the expected types."
-  (let (targets)
-    (cond
-     ((js2-name-node-p node)
-      (push node targets))
-     ((js2-array-node-p node)
-      (dolist (elt (js2-array-node-elems node))
-        (when elt
-          (setq elt (cond ((js2-infix-node-p elt) ;; default (=)
-                           (js2-infix-node-left elt))
-                          ((js2-unary-node-p elt) ;; rest (...)
-                           (js2-unary-node-operand elt))
-                          (t elt)))
-          (setq targets (append (js2--collect-target-symbols elt strict)
-                                targets)))))
-     ((js2-object-node-p node)
-      (dolist (elt (js2-object-node-elems node))
-        (let ((subexpr (cond
-                        ((and (js2-infix-node-p elt)
-                              (= js2-ASSIGN (js2-infix-node-type elt)))
-                         ;; Destructuring with default argument.
-                         (js2-infix-node-left elt))
-                        ((and (js2-infix-node-p elt)
-                              (= js2-COLON (js2-infix-node-type elt)))
-                         ;; In regular destructuring {a: aa, b: bb},
-                         ;; the var is on the right.  In abbreviated
-                         ;; destructuring {a, b}, right == left.
-                         (js2-infix-node-right elt))
-                        ((and (js2-unary-node-p elt)
-                              (= js2-TRIPLEDOT (js2-unary-node-type elt)))
-                         ;; Destructuring with spread.
-                         (js2-unary-node-operand elt)))))
-          (when subexpr
-            (setq targets (append
-                           (js2--collect-target-symbols subexpr strict)
-                           targets))))))
-     ((js2-assign-node-p node)
-      (setq targets (append (js2--collect-target-symbols
-                             (js2-assign-node-left node) strict)
-                            targets)))
-     (strict
-      (js2-report-error "msg.no.parm" nil (js2-node-abs-pos node)
-                        (js2-node-len node))
-        nil))
-    targets))
-
-(defun js2--examine-variable (parent node var-init-node)
-  "Examine the usage of the variable NODE, a js2-name-node.
-PARENT is its direct ancestor and VAR-INIT-NODE is the node to be
-examined: return a list of three values, respectively if the
-variable is declared and/or assigned or whether it is simply a
-key of a literal object."
-  (let ((target (js2-var-init-node-target var-init-node))
-        declared assigned object-key)
-    (setq declared (memq node (js2--collect-target-symbols target nil)))
-    ;; Is there an initializer for the declared variable?
-    (when (js2-var-init-node-initializer var-init-node)
-      (setq assigned declared)
-      ;; Determine if the name is actually a literal object key that we shall
-      ;; ignore later
-      (when (and (not declared)
-                 (js2-object-prop-node-p parent)
-                 (eq node (js2-object-prop-node-left parent))
-                 (not (eq node (js2-object-prop-node-right parent))))
-        (setq object-key t)))
-    ;; Maybe this is a for loop and the variable is one of its iterators?
-    (unless assigned
-      (let* ((gp (js2-node-parent parent))
-             (ggp (if gp (js2-node-parent gp))))
-        (when (and ggp (js2-for-in-node-p ggp))
-          (setq assigned (memq node
-                               (cl-loop
-                                for kid in (js2-var-decl-node-kids
-                                            (js2-for-in-node-iterator ggp))
-                                with syms = '()
-                                do
-                                (setq syms (append syms
-                                                   (js2--collect-target-symbols
-                                                    (js2-var-init-node-target kid)
-                                                    nil)))
-                                finally return syms))))))
-    (list declared assigned object-key)))
-
-(defun js2--is-param (var-node params)
-  "Recursively determine whether VAR-NODE is contained in PARAMS."
-  (cond ((js2-object-prop-node-p params)
-         (eq var-node (js2-object-prop-node-left params)))
-        ((js2-name-node-p params)
-         (eq var-node params))
-        (t
-         (let ((isparam (if (listp params)
-                            (memq var-node params)
-                          (cl-loop with found = nil
-                                   for p in (js2-node-child-list params)
-                                   while (null found)
-                                   do (setq found (eq var-node p))))))
-           (unless isparam
-             (let ((kids (if (listp params)
-                             params
-                           (js2-node-child-list params))))
-               (cl-loop for p in kids
-                        while (null isparam)
-                        do (setq isparam (js2--is-param var-node p)))))
-           isparam))))
-
-(defun js2--is-function-param (parent var-node)
-  "Determine whether VAR-NODE is a function parameter."
-  (while (and parent (not (js2-function-node-p parent)))
-    (if (or (js2-var-init-node-p parent)
-            (js2-assign-node-p parent))
-        (setq parent nil)
-    (setq parent (js2-node-parent parent))))
-  (when parent
-    (js2--is-param var-node (js2-function-node-params parent))))
-
-(defun js2--classify-variable (parent node vars)
-  "Classify the single variable NODE, a js2-name-node, updating the VARS collection."
-  (let ((function-param (js2--is-function-param parent node)))
-    (if (js2-prop-get-node-p parent)
-        ;; If we are within a prop-get, e.g. the "bar" in "foo.bar",
-        ;; just mark "foo" as used
-        (let ((left (js2-prop-get-node-left parent)))
-          (when (js2-name-node-p left)
-            (js2--add-or-update-symbol left nil t vars)))
-      ;; If the node is the external name of an export-binding-node, and
-      ;; it is different from the local name, ignore it
-      (when (or (not (js2-export-binding-node-p parent))
-                (not (and (eq (js2-export-binding-node-extern-name parent) node)
-                          (not (eq (js2-export-binding-node-local-name parent) node)))))
-        (let ((granparent parent)
-              var-init-node
-              assign-node
-              object-key         ; is name actually an object prop key?
-              declared           ; is it declared in narrowest scope?
-              assigned           ; does it get assigned or initialized?
-              (used (null function-param)))
-          ;; Determine the closest var-init-node and assign-node: this
-          ;; is needed because the name may be within a "destructured"
-          ;; declaration/assignment, so we cannot just take its parent
-          (while (and granparent (not (js2-scope-p granparent)))
-            (cond
-             ((js2-var-init-node-p granparent)
-              (when (null var-init-node)
-                (setq var-init-node granparent)))
-             ((js2-assign-node-p granparent)
-              (when (null assign-node)
-                (setq assign-node granparent))))
-            (setq granparent (js2-node-parent granparent)))
-
-          ;; If we are within a var-init-node, determine if the name is
-          ;; declared and initialized
-          (when var-init-node
-            (let ((result (js2--examine-variable parent node var-init-node)))
-              (setq declared (car result)
-                    assigned (cadr result)
-                    object-key (car (cddr result)))))
-
-          ;; Ignore literal object keys, which are not really variables
-          (unless object-key
-            (when function-param
-              (setq assigned ?P))
-
-            (when (null assigned)
-              (cond
-               ((js2-for-in-node-p parent)
-                (setq assigned (eq node (js2-for-in-node-iterator parent))
-                      used (not assigned)))
-               ((js2-function-node-p parent)
-                (setq assigned t
-                      used (js2-wrapper-function-p parent)))
-               ((js2-export-binding-node-p parent)
-                (if (js2-import-clause-node-p (js2-node-parent parent))
-                    (setq declared t
-                          assigned t)
-                  (setq used t)))
-               ((js2-namespace-import-node-p parent)
-                (setq assigned t
-                      used nil))
-               ((js2-class-node-p parent)
-                (setq declared t
-                      assigned t))
-               (assign-node
-                (setq assigned (memq node
-                                     (js2--collect-target-symbols
-                                      (js2-assign-node-left assign-node)
-                                      nil))
-                      used (not assigned)))))
-
-            (when declared
-              (setq used nil))
-
-            (js2--add-or-update-symbol node assigned used vars)))))))
-
-(defun js2--classify-variables ()
-  "Collect and classify variables declared or used within js2-mode-ast.
-Traverse the whole ast tree returning a summary of the variables
-usage as an hash-table, keyed by their corresponding symbol table
-entry.
-Each variable is described by a tuple where the car is a flag
-indicating whether the variable has been initialized and the cdr
-is a possibly empty list of name nodes where it is used. External
-symbols, i.e. those not present in the whole scopes hierarchy,
-are ignored."
-  (let ((vars (make-hash-table :test #'eq :size 100)))
-    (js2-visit-ast
-     js2-mode-ast
-     (lambda (node end-p)
-       (when (and (null end-p) (js2-name-node-p node))
-         (let ((parent (js2-node-parent node)))
-           (when parent
-             (js2--classify-variable parent node vars))))
-       t))
-    vars))
-
-(defun js2--get-name-node (node)
-  (cond
-   ((js2-name-node-p node) node)
-   ((js2-function-node-p node)
-    (js2-function-node-name node))
-   ((js2-class-node-p node)
-    (js2-class-node-name node))
-   ((js2-comp-loop-node-p node)
-    (js2-comp-loop-node-iterator node))
-   (t node)))
-
-(defun js2--highlight-unused-variable (symbol info)
-  (let ((name (js2-symbol-name symbol))
-        (inited (car info))
-        (refs (cdr info))
-        pos len)
-    (unless (and inited refs)
-      (if refs
-          (dolist (ref refs)
-            (setq pos (js2-node-abs-pos ref))
-            (setq len (js2-name-node-len ref))
-            (js2-report-warning "msg.uninitialized.variable" name pos len
-                                'js2-warning))
-        (when (or js2-warn-about-unused-function-arguments
-                  (not (eq inited ?P)))
-          (let* ((symn (js2-symbol-ast-node symbol))
-                 (namen (js2--get-name-node symn)))
-            (unless (js2-node-top-level-decl-p namen)
-              (setq pos (js2-node-abs-pos namen))
-              (setq len (js2-name-node-len namen))
-              (js2-report-warning "msg.unused.variable" name pos len
-                                  'js2-warning))))))))
-
-(defun js2-highlight-unused-variables ()
-  "Highlight unused variables."
-  (let ((vars (js2--classify-variables)))
-    (maphash #'js2--highlight-unused-variable vars)))
-
-;;;###autoload
-(define-minor-mode js2-highlight-unused-variables-mode
-  "Toggle highlight of unused variables."
-  :lighter ""
-  (if js2-highlight-unused-variables-mode
-      (add-hook 'js2-post-parse-callbacks
-                #'js2-highlight-unused-variables nil t)
-    (remove-hook 'js2-post-parse-callbacks
-                 #'js2-highlight-unused-variables t)))
-
-(defun js2-add-additional-externs (externs)
-  (setq js2-additional-externs
-        (nconc externs
-               js2-additional-externs)))
-
-(defun js2-get-jslint-comment-identifiers (comment)
-  (js2-reparse)
-  (cl-loop for node in (js2-ast-root-comments js2-mode-ast)
-           when (and (eq 'block (js2-comment-node-format node))
-                     (save-excursion
-                       (goto-char (js2-node-abs-pos node))
-                       (looking-at (concat "/\\* *" comment "\\(?: \\|$\\)"))))
-           append (js2-get-jslint-comment-identifiers-in
-                   (match-end 0)
-                   (js2-node-abs-end node))))
-
-(defun js2-get-jslint-comment-identifiers-in (beg end)
-  (let (res)
-    (save-excursion
-      (goto-char beg)
-      (while (re-search-forward js2-mode-identifier-re end t)
-        (let ((match (match-string 0)))
-          (unless (member match '("true" "false"))
-            (push match res)))))
-    (nreverse res)))
-
-(defun js2-apply-jslint-globals ()
-  (js2-add-additional-externs (js2-get-jslint-globals)))
-
-(defun js2-get-jslint-globals ()
-  (js2-get-jslint-comment-identifiers "global"))
-
-(defun js2-apply-jslint-declaration-externs ()
-  (js2-add-additional-externs (js2-get-jslint-declaration-externs)))
-
-(defvar js2-jslint-declaration-externs
-  `(("browser" . ,(mapcar 'symbol-name
-                          '(Audio clearInterval clearTimeout document
-                            event history Image location name
-                            navigator Option screen setInterval
-                            setTimeout XMLHttpRequest)))
-    ("node" . ,(mapcar 'symbol-name
-                       '(Buffer clearImmediate clearInterval
-                         clearTimeout console exports global module
-                         process querystring require setImmediate
-                         setInterval setTimeout __dirname
-                         __filename)))
-    ("es6" . ,(mapcar 'symbol-name
-                      '(ArrayBuffer DataView Float32Array
-                        Float64Array Int8Array Int16Array Int32Array
-                        Intl Map Promise Proxy Reflect Set Symbol
-                        System Uint8Array Uint8ClampedArray
-                        Uint16Array Uint32Array WeakMap WeakSet)))
-    ("couch" . ,(mapcar 'symbol-name
-                        '(emit getRow isArray log provides
-                          registerType require send start sum
-                          toJSON)))
-    ("devel" . ,(mapcar 'symbol-name
-                        '(alert confirm console Debug opera prompt
-                          WSH)))))
-
-(defun js2-get-jslint-declaration-externs ()
-  (apply 'append
-         (mapcar (lambda (identifier)
-                   (cdr (assoc identifier
-                               js2-jslint-declaration-externs)))
-                 (js2-get-jslint-comment-identifiers "jslint"))))
-
-;;; IMenu support
-
-;; We currently only support imenu, but eventually should support speedbar and
-;; possibly other browsing mechanisms.
-
-;; The basic strategy is to identify function assignment targets of the form
-;; `foo.bar.baz', convert them to (list fn foo bar baz <position>), and push the
-;; list into `js2-imenu-recorder'.  The lists are merged into a trie-like tree
-;; for imenu after parsing is finished.
-
-;; A `foo.bar.baz' assignment target may be expressed in many ways in
-;; JavaScript, and the general problem is undecidable.  However, several forms
-;; are readily recognizable at parse-time; the forms we attempt to recognize
-;; include:
-
-;;  function foo()  -- function declaration
-;;  foo = function()  -- function expression assigned to variable
-;;  foo.bar.baz = function()  -- function expr assigned to nested property-get
-;;  foo = {bar: function()}  -- fun prop in object literal assigned to var
-;;  foo = {bar: {baz: function()}} -- inside nested object literal
-;;  foo.bar = {baz: function()}} -- obj lit assigned to nested prop get
-;;  a.b = {c: {d: function()}} -- nested obj lit assigned to nested prop get
-;;  foo = {get bar() {...}}  -- getter/setter in obj literal
-;;  function foo() {function bar() {...}}  -- nested function
-;;  foo['a'] = function()  -- fun expr assigned to deterministic element-get
-
-;; This list boils down to a few forms that can be combined recursively.
-;; Top-level named function declarations include both the left-hand (name)
-;; and the right-hand (function value) expressions needed to produce an imenu
-;; entry.  The other "right-hand" forms we need to look for are:
-;;  - functions declared as props/getters/setters in object literals
-;;  - nested named function declarations
-;; The "left-hand" expressions that functions can be assigned to include:
-;;  - local/global variables
-;;  - nested property-get expressions like a.b.c.d
-;;  - element gets like foo[10] or foo['bar'] where the index
-;;    expression can be trivially converted to a property name.  They
-;;    effectively then become property gets.
-
-;; All the different definition types are canonicalized into the form
-;; foo.bar.baz = position-of-function-keyword
-
-;; We need to build a trie-like structure for imenu.  As an example,
-;; consider the following JavaScript code:
-
-;; a = function() {...}  // function at position 5
-;; b = function() {...}  // function at position 25
-;; foo = function() {...} // function at position 100
-;; foo.bar = function() {...} // function at position 200
-;; foo.bar.baz = function() {...} // function at position 300
-;; foo.bar.zab = function() {...} // function at position 400
-
-;; During parsing we accumulate an entry for each definition in
-;; the variable `js2-imenu-recorder', like so:
-
-;; '((fn a 5)
-;;   (fn b 25)
-;;   (fn foo 100)
-;;   (fn foo bar 200)
-;;   (fn foo bar baz 300)
-;;   (fn foo bar zab 400))
-
-;; Where 'fn' is the respective function node.
-;; After parsing these entries are merged into this alist-trie:
-
-;; '((a . 1)
-;;   (b . 2)
-;;   (foo (<definition> . 3)
-;;        (bar (<definition> . 6)
-;;             (baz . 100)
-;;             (zab . 200))))
-
-;; Note the wacky need for a <definition> name.  The token can be anything
-;; that isn't a valid JavaScript identifier, because you might make foo
-;; a function and then start setting properties on it that are also functions.
-
-(defun js2-prop-node-name (node)
-  "Return the name of a node that may be a property-get/property-name.
-If NODE is not a valid name-node, string-node or integral number-node,
-returns nil.  Otherwise returns the string name/value of the node."
-  (cond
-   ((js2-name-node-p node)
-    (js2-name-node-name node))
-   ((js2-string-node-p node)
-    (js2-string-node-value node))
-   ((and (js2-number-node-p node)
-         (string-match "^[0-9]+$" (js2-number-node-value node)))
-    (js2-number-node-value node))
-   ((eq (js2-node-type node) js2-THIS)
-    "this")
-   ((eq (js2-node-type node) js2-SUPER)
-    "super")))
-
-(defun js2-node-qname-component (node)
-  "Return the name of this node, if it contributes to a qname.
-Returns nil if the node doesn't contribute."
-  (copy-sequence
-   (or (js2-prop-node-name node)
-       (cond
-        ((and (js2-function-node-p node)
-              (js2-function-node-name node))
-         (js2-name-node-name (js2-function-node-name node)))
-        ((js2-computed-prop-name-node-p node)
-         "[computed]")))))
-
-(defun js2-record-imenu-entry (fn-node qname pos)
-  "Add an entry to `js2-imenu-recorder'.
-FN-NODE should be the current item's function node.
-
-Associate FN-NODE with its QNAME for later lookup.
-This is used in postprocessing the chain list.  For each chain, we find
-the parent function, look up its qname, then prepend a copy of it to the chain."
-  (push (cons fn-node (append qname (list pos))) js2-imenu-recorder)
-  (unless js2-imenu-function-map
-    (setq js2-imenu-function-map (make-hash-table :test 'eq)))
-  (puthash fn-node qname js2-imenu-function-map))
-
-(defun js2-record-imenu-functions (node &optional var)
-  "Record function definitions for imenu.
-NODE is a function node or an object literal.
-VAR, if non-nil, is the expression that NODE is being assigned to.
-When passed arguments of wrong type, does nothing."
-  (when js2-parse-ide-mode
-    (let ((fun-p (js2-function-node-p node))
-          qname fname-node)
-      (cond
-       ;; non-anonymous function declaration?
-       ((and fun-p
-             (not var)
-             (setq fname-node (js2-function-node-name node)))
-        (js2-record-imenu-entry node (list fname-node) (js2-node-pos node)))
-       ;; for remaining forms, compute left-side tree branch first
-       ((and var (setq qname (js2-compute-nested-prop-get var)))
-        (cond
-         ;; foo.bar.baz = function
-         (fun-p
-          (js2-record-imenu-entry node qname (js2-node-pos node)))
-         ;; foo.bar.baz = object-literal
-         ;; look for nested functions:  {a: {b: function() {...} }}
-         ((js2-object-node-p node)
-          ;; Node position here is still absolute, since the parser
-          ;; passes the assignment target and value expressions
-          ;; to us before they are added as children of the assignment node.
-          (js2-record-object-literal node qname (js2-node-pos node)))))))))
-
-(defun js2-compute-nested-prop-get (node)
-  "If NODE is of form foo.bar, foo['bar'], or any nested combination, return
-component nodes as a list.  Otherwise return nil.  Element-gets are treated
-as property-gets if the index expression is a string, or a positive integer."
-  (let (left right head)
-    (cond
-     ((or (js2-name-node-p node)
-          (js2-this-or-super-node-p node))
-      (list node))
-     ;; foo.bar.baz is parenthesized as (foo.bar).baz => right operand is a leaf
-     ((js2-prop-get-node-p node)        ; foo.bar
-      (setq left (js2-prop-get-node-left node)
-            right (js2-prop-get-node-right node))
-      (if (setq head (js2-compute-nested-prop-get left))
-          (nconc head (list right))))
-     ((js2-elem-get-node-p node)        ; foo['bar'] or foo[101]
-      (setq left (js2-elem-get-node-target node)
-            right (js2-elem-get-node-element node))
-      (if (or (js2-string-node-p right)      ; ['bar']
-              (and (js2-number-node-p right) ; [10]
-                   (string-match "^[0-9]+$"
-                                 (js2-number-node-value right))))
-          (if (setq head (js2-compute-nested-prop-get left))
-              (nconc head (list right))))))))
-
-(defun js2-record-object-literal (node qname pos)
-  "Recursively process an object literal looking for functions.
-NODE is an object literal that is the right-hand child of an assignment
-expression.  QNAME is a list of nodes representing the assignment target,
-e.g. for foo.bar.baz = {...}, QNAME is (foo-node bar-node baz-node).
-POS is the absolute position of the node.
-We do a depth-first traversal of NODE.  For any functions we find,
-we append the property name to QNAME, then call `js2-record-imenu-entry'."
-  (let (right)
-    (dolist (e (js2-object-node-elems node))  ; e is a `js2-object-prop-node'
-      (when (js2-infix-node-p e)
-        (let ((left (js2-infix-node-left e))
-              ;; Element positions are relative to the parent position.
-              (pos (+ pos (js2-node-pos e))))
-          (cond
-           ;; foo: function() {...}
-           ((js2-function-node-p (setq right (js2-infix-node-right e)))
-            (when (js2-prop-node-name left)
-              ;; As a policy decision, we record the position of the property,
-              ;; not the position of the `function' keyword, since the property
-              ;; is effectively the name of the function.
-              (js2-record-imenu-entry right (append qname (list left)) pos)))
-           ;; foo: {object-literal} -- add foo to qname, offset position, and recurse
-           ((js2-object-node-p right)
-            (js2-record-object-literal right
-                                       (append qname (list (js2-infix-node-left e)))
-                                       (+ pos (js2-node-pos right))))))))))
-
-(defun js2-node-top-level-decl-p (node)
-  "Return t if NODE's name is defined in the top-level scope.
-Also returns t if NODE's name is not defined in any scope, since it implies
-that it's an external variable, which must also be in the top-level scope."
-  (let* ((name (js2-prop-node-name node))
-         (this-scope (js2-node-get-enclosing-scope node))
-         defining-scope)
-    (cond
-     ((js2-this-or-super-node-p node)
-      nil)
-     ((null this-scope)
-      t)
-     ((setq defining-scope (js2-get-defining-scope this-scope name))
-      (js2-ast-root-p defining-scope))
-     (t t))))
-
-(defun js2-wrapper-function-p (node)
-  "Return t if NODE is a function expression that's immediately invoked.
-NODE must be `js2-function-node'."
-  (let ((parent (js2-node-parent node)))
-    (or
-     ;; function(){...}();
-     (and (js2-call-node-p parent)
-          (eq node (js2-call-node-target parent)))
-     (and (js2-paren-node-p parent)
-          ;; (function(){...})();
-          (or (js2-call-node-p (setq parent (js2-node-parent parent)))
-              ;; (function(){...}).call(this);
-              (and (js2-prop-get-node-p parent)
-                   (member (js2-name-node-name (js2-prop-get-node-right parent))
-                           '("call" "apply"))
-                   (js2-call-node-p (js2-node-parent parent))))))))
-
-(defun js2-browse-postprocess-chains ()
-  "Modify function-declaration name chains after parsing finishes.
-Some of the information is only available after the parse tree is complete.
-For instance, processing a nested scope requires a parent function node."
-  (let (result fn parent-qname p elem)
-    (dolist (entry js2-imenu-recorder)
-      ;; function node goes first
-      (cl-destructuring-bind (current-fn &rest (&whole chain head &rest)) entry
-        ;; Examine head's defining scope:
-        ;; Pre-processed chain, or top-level/external, keep as-is.
-        (if (or (stringp head) (js2-node-top-level-decl-p head))
-            (push chain result)
-          (when (js2-this-or-super-node-p head)
-            (setq chain (cdr chain))) ; discard this-node
-          (when (setq fn (js2-node-parent-script-or-fn current-fn))
-            (setq parent-qname (gethash fn js2-imenu-function-map 'not-found))
-            (when (eq parent-qname 'not-found)
-              ;; anonymous function expressions are not recorded
-              ;; during the parse, so we need to handle this case here
-              (setq parent-qname
-                    (if (js2-wrapper-function-p fn)
-                        (let ((grandparent (js2-node-parent-script-or-fn fn)))
-                          (if (js2-ast-root-p grandparent)
-                              nil
-                            (gethash grandparent js2-imenu-function-map 'skip)))
-                      'skip))
-              (puthash fn parent-qname js2-imenu-function-map))
-            (if (eq parent-qname 'skip)
-                ;; We don't show it, let's record that fact.
-                (remhash current-fn js2-imenu-function-map)
-              ;; Prepend parent fn qname to this chain.
-              (let ((qname (append parent-qname chain)))
-                (puthash current-fn (butlast qname) js2-imenu-function-map)
-                (push qname result)))))))
-    ;; Collect chains obtained by third-party code.
-    (let (js2-imenu-recorder)
-      (run-hooks 'js2-build-imenu-callbacks)
-      (dolist (entry js2-imenu-recorder)
-        (push (cdr entry) result)))
-    ;; Finally replace each node in each chain with its name.
-    (dolist (chain result)
-      (setq p chain)
-      (while p
-        (if (js2-node-p (setq elem (car p)))
-            (setcar p (js2-node-qname-component elem)))
-        (setq p (cdr p))))
-    result))
-
-;; Merge name chains into a trie-like tree structure of nested lists.
-;; To simplify construction of the trie, we first build it out using the rule
-;; that the trie consists of lists of pairs.  Each pair is a 2-element array:
-;; [key, num-or-list].  The second element can be a number; if so, this key
-;; is a leaf-node with only one value.  (I.e. there is only one declaration
-;; associated with the key at this level.)  Otherwise the second element is
-;; a list of pairs, with the rule applied recursively.  This symmetry permits
-;; a simple recursive formulation.
-;;
-;; js2-mode is building the data structure for imenu.  The imenu documentation
-;; claims that it's the structure above, but in practice it wants the children
-;; at the same list level as the key for that level, which is how I've drawn
-;; the "Expected final result" above.  We'll postprocess the trie to remove the
-;; list wrapper around the children at each level.
-;;
-;; A completed nested imenu-alist entry looks like this:
-;;       '(("foo"
-;;          ("<definition>" . 7)
-;;          ("bar"
-;;           ("a" . 40)
-;;           ("b" . 60))))
-;;
-;; In particular, the documentation for `imenu--index-alist' says that
-;; a nested sub-alist element looks like (INDEX-NAME SUB-ALIST).
-;; The sub-alist entries immediately follow INDEX-NAME, the head of the list.
-
-(defun js2-treeify (lst)
-  "Convert (a b c d) to (a ((b ((c d)))))."
-  (if (null (cddr lst))  ; list length <= 2
-      lst
-    (list (car lst) (list (js2-treeify (cdr lst))))))
-
-(defun js2-build-alist-trie (chains trie)
-  "Merge declaration name chains into a trie-like alist structure for imenu.
-CHAINS is the qname chain list produced during parsing. TRIE is a
-list of elements built up so far."
-  (let (head tail pos branch kids)
-    (dolist (chain chains)
-      (setq head (car chain)
-            tail (cdr chain)
-            pos (if (numberp (car tail)) (car tail))
-            branch (js2-find-if (lambda (n)
-                                  (string= (car n) head))
-                                trie)
-            kids (cl-second branch))
-      (cond
-       ;; case 1:  this key isn't in the trie yet
-       ((null branch)
-        (if trie
-            (setcdr (last trie) (list (js2-treeify chain)))
-          (setq trie (list (js2-treeify chain)))))
-       ;; case 2:  key is present with a single number entry:  replace w/ list
-       ;;  ("a1" 10)  +  ("a1" 20) => ("a1" (("<definition>" 10)
-       ;;                                    ("<definition>" 20)))
-       ((numberp kids)
-        (setcar (cdr branch)
-                (list (list "<definition-1>" kids)
-                      (if pos
-                          (list "<definition-2>" pos)
-                        (js2-treeify tail)))))
-       ;; case 3:  key is there (with kids), and we're a number entry
-       (pos
-        (setcdr (last kids)
-                (list
-                 (list (format "<definition-%d>"
-                               (1+ (cl-loop for kid in kids
-                                            count (eq ?< (aref (car kid) 0)))))
-                       pos))))
-       ;; case 4:  key is there with kids, need to merge in our chain
-       (t
-        (js2-build-alist-trie (list tail) kids))))
-    trie))
-
-(defun js2-flatten-trie (trie)
-  "Convert TRIE to imenu-format.
-Recurses through nodes, and for each one whose second element is a list,
-appends the list's flattened elements to the current element.  Also
-changes the tails into conses.  For instance, this pre-flattened trie
-
-'(a ((b 20)
-     (c ((d 30)
-         (e 40)))))
-
-becomes
-
-'(a (b . 20)
-    (c (d . 30)
-       (e . 40)))
-
-Note that the root of the trie has no key, just a list of chains.
-This is also true for the value of any key with multiple children,
-e.g. key 'c' in the example above."
-  (cond
-   ((listp (car trie))
-    (mapcar #'js2-flatten-trie trie))
-   (t
-    (if (numberp (cl-second trie))
-        (cons (car trie) (cl-second trie))
-      ;; else pop list and append its kids
-      (apply #'append (list (car trie)) (js2-flatten-trie (cdr trie)))))))
-
-(defun js2-build-imenu-index ()
-  "Turn `js2-imenu-recorder' into an imenu data structure."
-  (when (eq js2-imenu-recorder 'empty)
-    (setq js2-imenu-recorder nil))
-  (let* ((chains (js2-browse-postprocess-chains))
-         (result (js2-build-alist-trie chains nil)))
-    (js2-flatten-trie result)))
-
-(defun js2-test-print-chains (chains)
-  "Print a list of qname chains.
-Each element of CHAINS is a list of the form (NODE [NODE *] pos);
-i.e. one or more nodes, and an integer position as the list tail."
-  (mapconcat (lambda (chain)
-               (concat "("
-                       (mapconcat (lambda (elem)
-                                    (if (js2-node-p elem)
-                                        (or (js2-node-qname-component elem)
-                                            "nil")
-                                      (number-to-string elem)))
-                                  chain
-                                  " ")
-                       ")"))
-             chains
-             "\n"))
-
-;;; Parser
-
-(defconst js2-version "1.8.5"
-  "Version of JavaScript supported.")
-
-(defun js2-record-face (face &optional token)
-  "Record a style run of FACE for TOKEN or the current token."
-  (unless token (setq token (js2-current-token)))
-  (js2-set-face (js2-token-beg token) (js2-token-end token) face 'record))
-
-(defsubst js2-node-end (n)
-  "Computes the absolute end of node N.
-Use with caution!  Assumes `js2-node-pos' is -absolute-, which
-is only true until the node is added to its parent; i.e., while parsing."
-  (+ (js2-node-pos n)
-     (js2-node-len n)))
-
-(defun js2-record-comment (token)
-  "Record a comment in `js2-scanned-comments'."
-  (let ((ct (js2-token-comment-type token))
-        (beg (js2-token-beg token))
-        (end (js2-token-end token)))
-    (push (make-js2-comment-node :len (- end beg)
-                                 :format ct)
-          js2-scanned-comments)
-    (when js2-parse-ide-mode
-      (js2-record-face (if (eq ct 'jsdoc)
-                           'font-lock-doc-face
-                         'font-lock-comment-face)
-                       token)
-      (when (memq ct '(html preprocessor))
-        ;; Tell cc-engine the bounds of the comment.
-        (js2-record-text-property beg (1- end) 'c-in-sws t)))))
-
-(defun js2-peek-token (&optional modifier)
-  "Return the next token type without consuming it.
-If `js2-ti-lookahead' is positive, return the type of next token
-from `js2-ti-tokens'.  Otherwise, call `js2-get-token'."
-  (if (not (zerop js2-ti-lookahead))
-      (js2-token-type
-       (aref js2-ti-tokens (mod (1+ js2-ti-tokens-cursor) js2-ti-ntokens)))
-    (let ((tt (js2-get-token-internal modifier)))
-      (js2-unget-token)
-      tt)))
-
-(defalias 'js2-next-token 'js2-get-token)
-
-(defun js2-match-token (match &optional dont-unget)
-  "Get next token and return t if it matches MATCH, a bytecode.
-Returns nil and consumes nothing if MATCH is not the next token."
-  (if (/= (js2-get-token) match)
-      (ignore (unless dont-unget (js2-unget-token)))
-    t))
-
-(defun js2-match-contextual-kwd (name)
-  "Consume and return t if next token is `js2-NAME', and its
-string is NAME.  Returns nil and keeps current token otherwise."
-  (if (js2-contextual-kwd-p (progn (js2-get-token)
-                                   (js2-current-token))
-                            name)
-      (progn (js2-record-face 'font-lock-keyword-face) t)
-    (js2-unget-token)
-    nil))
-
-(defun js2-contextual-kwd-p (token name)
-  "Return t if TOKEN is `js2-NAME', and its string is NAME."
-  (and (= (js2-token-type token) js2-NAME)
-       (string= (js2-token-string token) name)))
-
-(defun js2-match-async-function ()
-  (when (and (js2-contextual-kwd-p (js2-current-token) "async")
-             (= (js2-peek-token) js2-FUNCTION))
-    (js2-record-face 'font-lock-keyword-face)
-    (js2-get-token)
-    t))
-
-(defun js2-match-async-arrow-function ()
-  (and (js2-contextual-kwd-p (js2-current-token) "async")
-       (/= (js2-peek-token) js2-FUNCTION)))
-
-(defsubst js2-inside-function ()
-  (cl-plusp js2-nesting-of-function))
-
-(defsubst js2-inside-async-function ()
-  (and (js2-inside-function)
-       (js2-function-node-async js2-current-script-or-fn)))
-
-(defun js2-parse-await-maybe (tt)
-  "Parse \"await\" as an AwaitExpression, if it is one."
-  (and (= tt js2-NAME)
-       (js2-contextual-kwd-p (js2-current-token) "await")
-       ;; Per the proposal, AwaitExpression consists of "await"
-       ;; followed by a UnaryExpression.  So look ahead for one.
-       (let ((ts-state (make-js2-ts-state))
-             (recorded-identifiers js2-recorded-identifiers)
-             (parsed-errors js2-parsed-errors)
-             (current-token (js2-current-token))
-             (beg (js2-current-token-beg))
-             (end (js2-current-token-end))
-             pn)
-         (js2-get-token)
-         (setq pn (js2-make-unary beg js2-AWAIT 'js2-parse-unary-expr))
-         (if (= (js2-node-type (js2-unary-node-operand pn)) js2-ERROR)
-             ;; The parse failed, so pretend like nothing happened and restore
-             ;; the previous parsing state.
-             (progn
-               (js2-ts-seek ts-state)
-               (setq js2-recorded-identifiers recorded-identifiers
-                     js2-parsed-errors parsed-errors)
-               ;; And ensure the caller knows about the failure.
-               nil)
-           ;; The parse was successful, so process and return the "await".
-           (js2-record-face 'font-lock-keyword-face current-token)
-           (unless (js2-inside-async-function)
-             (js2-report-error "msg.bad.await" nil
-                               beg (- end beg)))
-           pn))))
-
-(defun js2-get-prop-name-token ()
-  (js2-get-token (and (>= js2-language-version 170) 'KEYWORD_IS_NAME)))
-
-(defun js2-match-prop-name ()
-  "Consume token and return t if next token is a valid property name.
-If `js2-language-version' is >= 180, a keyword or reserved word
-is considered valid name as well."
-  (if (eq js2-NAME (js2-get-prop-name-token))
-      t
-    (js2-unget-token)
-    nil))
-
-(defun js2-must-match-prop-name (msg-id &optional pos len)
-  (if (js2-match-prop-name)
-      t
-    (js2-report-error msg-id nil pos len)
-    nil))
-
-(defun js2-peek-token-or-eol ()
-  "Return js2-EOL if the next token immediately follows a newline.
-Else returns the next token.  Used in situations where we don't
-consider certain token types valid if they are preceded by a newline.
-One example is the postfix ++ or -- operator, which has to be on the
-same line as its operand."
-  (let ((tt (js2-get-token))
-        (follows-eol (js2-token-follows-eol-p (js2-current-token))))
-    (js2-unget-token)
-    (if follows-eol
-        js2-EOL
-      tt)))
-
-(defun js2-must-match (token msg-id &optional pos len)
-  "Match next token to token code TOKEN, or record a syntax error.
-MSG-ID is the error message to report if the match fails.
-Returns t on match, nil if no match."
-  (if (js2-match-token token t)
-      t
-    (js2-report-error msg-id nil pos len)
-    (js2-unget-token)
-    nil))
-
-(defun js2-must-match-name (msg-id)
-  (if (js2-match-token js2-NAME t)
-      t
-    (if (eq (js2-current-token-type) js2-RESERVED)
-        (js2-report-error "msg.reserved.id" (js2-current-token-string))
-      (js2-report-error msg-id)
-      (js2-unget-token))
-    nil))
-
-(defun js2-set-requires-activation ()
-  (if (js2-function-node-p js2-current-script-or-fn)
-      (setf (js2-function-node-needs-activation js2-current-script-or-fn) t)))
-
-(defun js2-check-activation-name (name _token)
-  (when (js2-inside-function)
-    ;; skip language-version 1.2 check from Rhino
-    (if (or (string= "arguments" name)
-            (and js2-compiler-activation-names  ; only used in codegen
-                 (gethash name js2-compiler-activation-names)))
-        (js2-set-requires-activation))))
-
-(defun js2-set-is-generator ()
-  (let ((fn-node js2-current-script-or-fn))
-    (when (and (js2-function-node-p fn-node)
-               (not (js2-function-node-generator-type fn-node)))
-      (setf (js2-function-node-generator-type js2-current-script-or-fn) 'LEGACY))))
-
-(defun js2-must-have-xml ()
-  (unless js2-compiler-xml-available
-    (js2-report-error "msg.XML.not.available")))
-
-(defun js2-push-scope (scope)
-  "Push SCOPE, a `js2-scope', onto the lexical scope chain."
-  (cl-assert (js2-scope-p scope))
-  (cl-assert (null (js2-scope-parent-scope scope)))
-  (cl-assert (not (eq js2-current-scope scope)))
-  (setf (js2-scope-parent-scope scope) js2-current-scope
-        js2-current-scope scope))
-
-(defsubst js2-pop-scope ()
-  (setq js2-current-scope
-        (js2-scope-parent-scope js2-current-scope)))
-
-(defun js2-enter-loop (loop-node)
-  (push loop-node js2-loop-set)
-  (push loop-node js2-loop-and-switch-set)
-  (js2-push-scope loop-node)
-  ;; Tell the current labeled statement (if any) its statement,
-  ;; and set the jump target of the first label to the loop.
-  ;; These are used in `js2-parse-continue' to verify that the
-  ;; continue target is an actual labeled loop.  (And for codegen.)
-  (when js2-labeled-stmt
-    (setf (js2-labeled-stmt-node-stmt js2-labeled-stmt) loop-node
-          (js2-label-node-loop (car (js2-labeled-stmt-node-labels
-                                     js2-labeled-stmt))) loop-node)))
-
-(defun js2-exit-loop ()
-  (pop js2-loop-set)
-  (pop js2-loop-and-switch-set)
-  (js2-pop-scope))
-
-(defsubst js2-enter-switch (switch-node)
-  (js2-push-scope switch-node)
-  (push switch-node js2-loop-and-switch-set))
-
-(defsubst js2-exit-switch ()
-  (js2-pop-scope)
-  (pop js2-loop-and-switch-set))
-
-(defsubst js2-get-directive (node)
-  "Return NODE's value if it is a directive, nil otherwise.
-
-A directive is an otherwise-meaningless expression statement
-consisting of a string literal, such as \"use strict\"."
-  (and (js2-expr-stmt-node-p node)
-       (js2-string-node-p (setq node (js2-expr-stmt-node-expr node)))
-       (js2-string-node-value node)))
-
-(defun js2-parse (&optional buf cb)
-  "Tell the js2 parser to parse a region of JavaScript.
-
-BUF is a buffer or buffer name containing the code to parse.
-Call `narrow-to-region' first to parse only part of the buffer.
-
-The returned AST root node is given some additional properties:
-  `node-count' - total number of nodes in the AST
-  `buffer' - BUF.  The buffer it refers to may change or be killed,
-             so the value is not necessarily reliable.
-
-An optional callback CB can be specified to report parsing
-progress.  If `(functionp CB)' returns t, it will be called with
-the current line number once before parsing begins, then again
-each time the lexer reaches a new line number.
-
-CB can also be a list of the form `(symbol cb ...)' to specify
-multiple callbacks with different criteria.  Each symbol is a
-criterion keyword, and the following element is the callback to
-call
-
-  :line  - called whenever the line number changes
-  :token - called for each new token consumed
-
-The list of criteria could be extended to include entering or
-leaving a statement, an expression, or a function definition."
-  (if (and cb (not (functionp cb)))
-      (error "criteria callbacks not yet implemented"))
-  (let ((inhibit-point-motion-hooks t)
-        (js2-compiler-xml-available (>= js2-language-version 160))
-        ;; This is a recursive-descent parser, so give it a big stack.
-        (max-lisp-eval-depth (max max-lisp-eval-depth 3000))
-        (max-specpdl-size (max max-specpdl-size 3000))
-        (case-fold-search nil)
-        ast)
-    (with-current-buffer (or buf (current-buffer))
-      (setq js2-scanned-comments nil
-            js2-parsed-errors nil
-            js2-parsed-warnings nil
-            js2-imenu-recorder nil
-            js2-imenu-function-map nil
-            js2-label-set nil)
-      (js2-init-scanner)
-      (setq ast (js2-do-parse))
-      (unless js2-ts-hit-eof
-        (js2-report-error "msg.got.syntax.errors" (length js2-parsed-errors)))
-      (setf (js2-ast-root-errors ast) js2-parsed-errors
-            (js2-ast-root-warnings ast) js2-parsed-warnings)
-      ;; if we didn't find any declarations, put a dummy in this list so we
-      ;; don't end up re-parsing the buffer in `js2-mode-create-imenu-index'
-      (unless js2-imenu-recorder
-        (setq js2-imenu-recorder 'empty))
-      (run-hooks 'js2-parse-finished-hook)
-      ast)))
-
-;; Corresponds to Rhino's Parser.parse() method.
-(defun js2-do-parse ()
-  "Parse current buffer starting from current point.
-Scanner should be initialized."
-  (let ((pos js2-ts-cursor)
-        (end js2-ts-cursor)  ; in case file is empty
-        root n tt
-        (in-directive-prologue t)
-        (js2-in-use-strict-directive js2-in-use-strict-directive)
-        directive)
-    ;; initialize buffer-local parsing vars
-    (setf root (make-js2-ast-root :buffer (buffer-name) :pos pos)
-          js2-current-script-or-fn root
-          js2-current-scope root
-          js2-nesting-of-function 0
-          js2-labeled-stmt nil
-          js2-recorded-identifiers nil  ; for js2-highlight
-          js2-in-use-strict-directive js2-mode-assume-strict)
-    (while (/= (setq tt (js2-get-token)) js2-EOF)
-      (if (= tt js2-FUNCTION)
-          (progn
-            (setq n (if js2-called-by-compile-function
-                        (js2-parse-function-expr)
-                      (js2-parse-function-stmt))))
-        ;; not a function - parse a statement
-        (js2-unget-token)
-        (setq n (js2-parse-statement))
-        (when in-directive-prologue
-          (setq directive (js2-get-directive n))
-          (cond
-           ((null directive)
-            (setq in-directive-prologue nil))
-           ((string= directive "use strict")
-            (setq js2-in-use-strict-directive t)))))
-      ;; add function or statement to script
-      (setq end (js2-node-end n))
-      (js2-block-node-push root n))
-    ;; add comments to root in lexical order
-    (when js2-scanned-comments
-      ;; if we find a comment beyond end of normal kids, use its end
-      (setq end (max end (js2-node-end (cl-first js2-scanned-comments))))
-      (dolist (comment js2-scanned-comments)
-        (push comment (js2-ast-root-comments root))
-        (js2-node-add-children root comment)))
-    (setf (js2-node-len root) (- end pos))
-    (setq js2-mode-ast root)  ; Make sure this is available for callbacks.
-    ;; Give extensions a chance to muck with things before highlighting starts.
-    (let ((js2-additional-externs js2-additional-externs))
-      (js2-filter-parsed-warnings)
-      (save-excursion
-        (run-hooks 'js2-post-parse-callbacks))
-      (js2-highlight-undeclared-vars))
-    root))
-
-(defun js2-filter-parsed-warnings ()
-  "Remove `js2-parsed-warnings' elements that match `js2-ignored-warnings'."
-  (when js2-ignored-warnings
-    (setq js2-parsed-warnings
-          (cl-remove-if
-           (lambda (warning)
-             (let ((msg (caar warning)))
-               (member msg js2-ignored-warnings)))
-           js2-parsed-warnings)))
-  js2-parsed-warnings)
-
-(defun js2-parse-function-closure-body (fn-node)
-  "Parse a JavaScript 1.8 function closure body."
-  (let ((js2-nesting-of-function (1+ js2-nesting-of-function)))
-    (if js2-ts-hit-eof
-        (js2-report-error "msg.no.brace.body" nil
-                          (js2-node-pos fn-node)
-                          (- js2-ts-cursor (js2-node-pos fn-node)))
-      (js2-node-add-children fn-node
-                             (setf (js2-function-node-body fn-node)
-                                   (js2-parse-expr t))))))
-
-(defun js2-parse-function-body (fn-node)
-  (js2-must-match js2-LC "msg.no.brace.body"
-                  (js2-node-pos fn-node)
-                  (- js2-ts-cursor (js2-node-pos fn-node)))
-  (let ((pos (js2-current-token-beg))         ; LC position
-        (pn (make-js2-block-node))  ; starts at LC position
-        tt
-        end
-        not-in-directive-prologue
-        node
-        directive)
-    (cl-incf js2-nesting-of-function)
-    (unwind-protect
-        (while (not (or (= (setq tt (js2-peek-token)) js2-ERROR)
-                        (= tt js2-EOF)
-                        (= tt js2-RC)))
-          (js2-block-node-push
-           pn
-           (if (/= tt js2-FUNCTION)
-               (if not-in-directive-prologue
-                   (js2-parse-statement)
-                 (setq node (js2-parse-statement)
-                       directive (js2-get-directive node))
-                 (cond
-                  ((null directive)
-                   (setq not-in-directive-prologue t))
-                  ((string= directive "use strict")
-                   ;; Back up and reparse the function, because new rules apply
-                   ;; to the function name and parameters.
-                   (when (not js2-in-use-strict-directive)
-                     (setq js2-in-use-strict-directive t)
-                     (throw 'reparse t))))
-                 node)
-             (js2-get-token)
-             (js2-parse-function-stmt))))
-      (cl-decf js2-nesting-of-function))
-    (setq end (js2-current-token-end))  ; assume no curly and leave at current token
-    (if (js2-must-match js2-RC "msg.no.brace.after.body" pos)
-        (setq end (js2-current-token-end)))
-    (setf (js2-node-pos pn) pos
-          (js2-node-len pn) (- end pos))
-    (setf (js2-function-node-body fn-node) pn)
-    (js2-node-add-children fn-node pn)
-    pn))
-
-(defun js2-define-destruct-symbols (node decl-type face &optional ignore-not-in-block)
-  "Declare and fontify destructuring parameters inside NODE.
-NODE is either `js2-array-node', `js2-object-node', or `js2-name-node'.
-
-Return a list of `js2-name-node' nodes representing the symbols
-declared; probably to check them for errors."
-  (let ((name-nodes (js2--collect-target-symbols node t)))
-    (dolist (node name-nodes)
-      (let (leftpos)
-        (js2-define-symbol decl-type (js2-name-node-name node)
-                           node ignore-not-in-block)
-        (when face
-          (js2-set-face (setq leftpos (js2-node-abs-pos node))
-                        (+ leftpos (js2-node-len node))
-                        face 'record))))
-    name-nodes))
-
-(defvar js2-illegal-strict-identifiers
-  '("eval" "arguments")
-  "Identifiers not allowed as variables in strict mode.")
-
-(defun js2-check-strict-identifier (name-node)
-  "Check that NAME-NODE makes a legal strict mode identifier."
-  (when js2-in-use-strict-directive
-    (let ((param-name (js2-name-node-name name-node)))
-      (when (member param-name js2-illegal-strict-identifiers)
-        (js2-report-error "msg.bad.id.strict" param-name
-                          (js2-node-abs-pos name-node) (js2-node-len name-node))))))
-
-(defun js2-check-strict-function-params (preceding-params params)
-  "Given PRECEDING-PARAMS in a function's parameter list, check
-for strict mode errors caused by PARAMS."
-  (when js2-in-use-strict-directive
-    (dolist (param params)
-      (let ((param-name (js2-name-node-name param)))
-        (js2-check-strict-identifier param)
-        (when (cl-some (lambda (param)
-                         (string= (js2-name-node-name param) param-name))
-                       preceding-params)
-          (js2-report-error "msg.dup.param.strict" param-name
-                            (js2-node-abs-pos param) (js2-node-len param)))))))
-
-(defun js2-parse-function-params (function-type fn-node pos)
-  "Parse the parameters of a function of FUNCTION-TYPE
-represented by FN-NODE at POS."
-  (if (js2-match-token js2-RP)
-      (setf (js2-function-node-rp fn-node) (- (js2-current-token-beg) pos))
-    (let ((paren-free-arrow (and (eq function-type 'FUNCTION_ARROW)
-                                 (eq (js2-current-token-type) js2-NAME)))
-          params param
-          param-name-nodes new-param-name-nodes
-          rest-param-at)
-      (when paren-free-arrow
-        (js2-unget-token))
-      (cl-loop for tt = (js2-peek-token)
-               do
-               (cond
-                ;; destructuring param
-                ((and (not paren-free-arrow)
-                      (or (= tt js2-LB) (= tt js2-LC)))
-                 (js2-get-token)
-                 (setq param (js2-parse-destruct-primary-expr)
-                       new-param-name-nodes (js2-define-destruct-symbols
-                                             param js2-LP 'js2-function-param))
-                 (js2-check-strict-function-params param-name-nodes new-param-name-nodes)
-                 (setq param-name-nodes (append param-name-nodes new-param-name-nodes)))
-                ;; variable name
-                (t
-                 (when (and (>= js2-language-version 200)
-                            (not paren-free-arrow)
-                            (js2-match-token js2-TRIPLEDOT)
-                            (not rest-param-at))
-                   ;; to report errors if there are more parameters
-                   (setq rest-param-at (length params)))
-                 (js2-must-match-name "msg.no.parm")
-                 (js2-record-face 'js2-function-param)
-                 (setq param (js2-create-name-node))
-                 (js2-define-symbol js2-LP (js2-current-token-string) param)
-                 (js2-check-strict-function-params param-name-nodes (list param))
-                 (setq param-name-nodes (append param-name-nodes (list param)))))
-               ;; default parameter value
-               (when (and (not rest-param-at)
-                          (>= js2-language-version 200)
-                          (js2-match-token js2-ASSIGN))
-                 (cl-assert (not paren-free-arrow))
-                 (let* ((pos (js2-node-pos param))
-                        (tt (js2-current-token-type))
-                        (op-pos (- (js2-current-token-beg) pos))
-                        (left param)
-                        (right (js2-parse-assign-expr))
-                        (len (- (js2-node-end right) pos)))
-                   (setq param (make-js2-assign-node
-                                :type tt :pos pos :len len :op-pos op-pos
-                                :left left :right right))
-                   (js2-node-add-children param left right)))
-               (push param params)
-               (when (and rest-param-at (> (length params) (1+ rest-param-at)))
-                 (js2-report-error "msg.param.after.rest" nil
-                                   (js2-node-pos param) (js2-node-len param)))
-               while
-               (and (js2-match-token js2-COMMA)
-                    (or (< js2-language-version 200)
-                        (not (= js2-RP (js2-peek-token))))))
-      (when (and (not paren-free-arrow)
-                 (js2-must-match js2-RP "msg.no.paren.after.parms"))
-        (setf (js2-function-node-rp fn-node) (- (js2-current-token-beg) pos)))
-      (when rest-param-at
-        (setf (js2-function-node-rest-p fn-node) t))
-      (dolist (p params)
-        (js2-node-add-children fn-node p)
-        (push p (js2-function-node-params fn-node))))))
-
-(defun js2-check-inconsistent-return-warning (fn-node name)
-  "Possibly show inconsistent-return warning.
-Last token scanned is the close-curly for the function body."
-  (when (and js2-mode-show-strict-warnings
-             js2-strict-inconsistent-return-warning
-             (not (js2-has-consistent-return-usage
-                   (js2-function-node-body fn-node))))
-    ;; Have it extend from close-curly to bol or beginning of block.
-    (let ((pos (save-excursion
-                 (goto-char (js2-current-token-end))
-                 (max (js2-node-abs-pos (js2-function-node-body fn-node))
-                      (point-at-bol))))
-          (end (js2-current-token-end)))
-      (if (cl-plusp (js2-name-node-length name))
-          (js2-add-strict-warning "msg.no.return.value"
-                                  (js2-name-node-name name) pos end)
-        (js2-add-strict-warning "msg.anon.no.return.value" nil pos end)))))
-
-(defun js2-parse-function-stmt (&optional async-p)
-  (let ((pos (js2-current-token-beg))
-        (star-p (js2-match-token js2-MUL)))
-    (js2-must-match-name "msg.unnamed.function.stmt")
-    (let ((name (js2-create-name-node t))
-          pn member-expr)
-      (cond
-       ((js2-match-token js2-LP)
-        (js2-parse-function 'FUNCTION_STATEMENT pos star-p async-p name))
-       (js2-allow-member-expr-as-function-name
-        (setq member-expr (js2-parse-member-expr-tail nil name))
-        (js2-parse-highlight-member-expr-fn-name member-expr)
-        (js2-must-match js2-LP "msg.no.paren.parms")
-        (setf pn (js2-parse-function 'FUNCTION_STATEMENT pos star-p async-p)
-              (js2-function-node-member-expr pn) member-expr)
-        pn)
-       (t
-        (js2-report-error "msg.no.paren.parms")
-        (make-js2-error-node))))))
-
-(defun js2-parse-async-function-stmt ()
-  (js2-parse-function-stmt t))
-
-(defun js2-parse-function-expr (&optional async-p)
-  (let ((pos (js2-current-token-beg))
-        (star-p (js2-match-token js2-MUL))
-        name)
-    (when (js2-match-token js2-NAME)
-      (setq name (js2-create-name-node t)))
-    (js2-must-match js2-LP "msg.no.paren.parms")
-    (js2-parse-function 'FUNCTION_EXPRESSION pos star-p async-p name)))
-
-(defun js2-parse-function-internal (function-type pos star-p &optional async-p name)
-  (let (fn-node lp)
-    (if (= (js2-current-token-type) js2-LP) ; eventually matched LP?
-        (setq lp (js2-current-token-beg)))
-    (setf fn-node (make-js2-function-node :pos pos
-                                          :name name
-                                          :form function-type
-                                          :lp (if lp (- lp pos))
-                                          :generator-type (and star-p 'STAR)
-                                          :async async-p))
-    (when name
-      (js2-set-face (js2-node-pos name) (js2-node-end name)
-                    'font-lock-function-name-face 'record)
-      (when (and (eq function-type 'FUNCTION_STATEMENT)
-                 (cl-plusp (js2-name-node-length name)))
-        ;; Function statements define a symbol in the enclosing scope
-        (js2-define-symbol js2-FUNCTION (js2-name-node-name name) fn-node))
-      (when js2-in-use-strict-directive
-        (js2-check-strict-identifier name)))
-    (if (or (js2-inside-function) (cl-plusp js2-nesting-of-with))
-        ;; 1. Nested functions are not affected by the dynamic scope flag
-        ;;    as dynamic scope is already a parent of their scope.
-        ;; 2. Functions defined under the with statement also immune to
-        ;;    this setup, in which case dynamic scope is ignored in favor
-        ;;    of the with object.
-        (setf (js2-function-node-ignore-dynamic fn-node) t))
-    ;; dynamically bind all the per-function variables
-    (let ((js2-current-script-or-fn fn-node)
-          (js2-current-scope fn-node)
-          (js2-nesting-of-with 0)
-          (js2-end-flags 0)
-          js2-label-set
-          js2-loop-set
-          js2-loop-and-switch-set)
-      (js2-parse-function-params function-type fn-node pos)
-      (when (eq function-type 'FUNCTION_ARROW)
-        (js2-must-match js2-ARROW "msg.bad.arrow.args"))
-      (if (and (>= js2-language-version 180)
-               (/= (js2-peek-token) js2-LC))
-          (js2-parse-function-closure-body fn-node)
-        (js2-parse-function-body fn-node))
-      (js2-check-inconsistent-return-warning fn-node name)
-
-      (when name
-        (js2-node-add-children fn-node name)
-        ;; Function expressions define a name only in the body of the
-        ;; function, and only if not hidden by a parameter name
-        (when (and (eq function-type 'FUNCTION_EXPRESSION)
-                   (null (js2-scope-get-symbol js2-current-scope
-                                               (js2-name-node-name name))))
-          (js2-define-symbol js2-FUNCTION
-                             (js2-name-node-name name)
-                             fn-node))
-        (when (eq function-type 'FUNCTION_STATEMENT)
-          (js2-record-imenu-functions fn-node))))
-
-    (setf (js2-node-len fn-node) (- (js2-current-token-end) pos))
-    ;; Rhino doesn't do this, but we need it for finding undeclared vars.
-    ;; We wait until after parsing the function to set its parent scope,
-    ;; since `js2-define-symbol' needs the defining-scope check to stop
-    ;; at the function boundary when checking for redeclarations.
-    (setf (js2-scope-parent-scope fn-node) js2-current-scope)
-    fn-node))
-
-(defun js2-parse-function (function-type pos star-p &optional async-p name)
-  "Function parser.  FUNCTION-TYPE is a symbol, POS is the
-beginning of the first token (function keyword, unless it's an
-arrow function), NAME is js2-name-node."
-  (let ((continue t)
-        ts-state
-        fn-node
-        ;; Preserve strict state outside this function.
-        (js2-in-use-strict-directive js2-in-use-strict-directive))
-    ;; Parse multiple times if a new strict mode directive is discovered in the
-    ;; function body, as new rules will be retroactively applied to the legality
-    ;; of function names and parameters.
-    (while continue
-      (setq ts-state (make-js2-ts-state))
-      (setq continue (catch 'reparse
-                       (setq fn-node (js2-parse-function-internal
-                                      function-type pos star-p async-p name))
-                       ;; Don't continue.
-                       nil))
-      (when continue
-        (js2-ts-seek ts-state)))
-    fn-node))
-
-(defun js2-parse-statements (&optional parent)
-  "Parse a statement list.  Last token consumed must be js2-LC.
-
-PARENT can be a `js2-block-node', in which case the statements are
-appended to PARENT.  Otherwise a new `js2-block-node' is created
-and returned.
-
-This function does not match the closing js2-RC: the caller
-matches the RC so it can provide a suitable error message if not
-matched.  This means it's up to the caller to set the length of
-the node to include the closing RC.  The node start pos is set to
-the absolute buffer start position, and the caller should fix it
-up to be relative to the parent node.  All children of this block
-node are given relative start positions and correct lengths."
-  (let ((pn (or parent (make-js2-block-node)))
-        tt)
-    (while (and (> (setq tt (js2-peek-token)) js2-EOF)
-                (/= tt js2-RC))
-      (js2-block-node-push pn (js2-parse-statement)))
-    pn))
-
-(defun js2-parse-statement ()
-  (let (pn beg end)
-    ;; coarse-grained user-interrupt check - needs work
-    (and js2-parse-interruptable-p
-         (zerop (% (cl-incf js2-parse-stmt-count)
-                   js2-statements-per-pause))
-         (input-pending-p)
-         (throw 'interrupted t))
-    (setq pn (js2-statement-helper))
-    ;; no-side-effects warning check
-    (unless (js2-node-has-side-effects pn)
-      (setq end (js2-node-end pn))
-      (save-excursion
-        (goto-char end)
-        (setq beg (max (js2-node-pos pn) (point-at-bol))))
-      (js2-add-strict-warning "msg.no.side.effects" nil beg end))
-    pn))
-
-;; These correspond to the switch cases in Parser.statementHelper
-(defconst js2-parsers
-  (let ((parsers (make-vector js2-num-tokens
-                                #'js2-parse-expr-stmt)))
-    (aset parsers js2-BREAK     #'js2-parse-break)
-    (aset parsers js2-CLASS     #'js2-parse-class-stmt)
-    (aset parsers js2-CONST     #'js2-parse-const-var)
-    (aset parsers js2-CONTINUE  #'js2-parse-continue)
-    (aset parsers js2-DEBUGGER  #'js2-parse-debugger)
-    (aset parsers js2-DEFAULT   #'js2-parse-default-xml-namespace)
-    (aset parsers js2-DO        #'js2-parse-do)
-    (aset parsers js2-EXPORT    #'js2-parse-export)
-    (aset parsers js2-FOR       #'js2-parse-for)
-    (aset parsers js2-FUNCTION  #'js2-parse-function-stmt)
-    (aset parsers js2-IF        #'js2-parse-if)
-    (aset parsers js2-IMPORT    #'js2-parse-import)
-    (aset parsers js2-LC        #'js2-parse-block)
-    (aset parsers js2-LET       #'js2-parse-let-stmt)
-    (aset parsers js2-NAME      #'js2-parse-name-or-label)
-    (aset parsers js2-RETURN    #'js2-parse-ret-yield)
-    (aset parsers js2-SEMI      #'js2-parse-semi)
-    (aset parsers js2-SWITCH    #'js2-parse-switch)
-    (aset parsers js2-THROW     #'js2-parse-throw)
-    (aset parsers js2-TRY       #'js2-parse-try)
-    (aset parsers js2-VAR       #'js2-parse-const-var)
-    (aset parsers js2-WHILE     #'js2-parse-while)
-    (aset parsers js2-WITH      #'js2-parse-with)
-    (aset parsers js2-YIELD     #'js2-parse-ret-yield)
-    parsers)
-  "A vector mapping token types to parser functions.")
-
-(defun js2-parse-warn-missing-semi (beg end)
-  (and js2-mode-show-strict-warnings
-       js2-strict-missing-semi-warning
-       (js2-add-strict-warning
-        "msg.missing.semi" nil
-        ;; back up to beginning of statement or line
-        (max beg (save-excursion
-                   (goto-char end)
-                   (point-at-bol)))
-        end)))
-
-(defconst js2-no-semi-insertion
-  (list js2-IF
-        js2-SWITCH
-        js2-WHILE
-        js2-DO
-        js2-FOR
-        js2-TRY
-        js2-WITH
-        js2-LC
-        js2-ERROR
-        js2-SEMI
-        js2-CLASS
-        js2-FUNCTION
-        js2-EXPORT)
-  "List of tokens that don't do automatic semicolon insertion.")
-
-(defconst js2-autoinsert-semi-and-warn
-  (list js2-ERROR js2-EOF js2-RC))
-
-(defun js2-statement-helper ()
-  (let* ((tt (js2-get-token))
-         (first-tt tt)
-         (async-stmt (js2-match-async-function))
-         (parser (if (= tt js2-ERROR)
-                     #'js2-parse-semi
-                   (if async-stmt
-                       #'js2-parse-async-function-stmt
-                     (aref js2-parsers tt))))
-         pn)
-    ;; If the statement is set, then it's been told its label by now.
-    (and js2-labeled-stmt
-         (js2-labeled-stmt-node-stmt js2-labeled-stmt)
-         (setq js2-labeled-stmt nil))
-    (setq pn (funcall parser))
-    ;; Don't do auto semi insertion for certain statement types.
-    (unless (or (memq first-tt js2-no-semi-insertion)
-                (js2-labeled-stmt-node-p pn)
-                async-stmt)
-      (js2-auto-insert-semicolon pn))
-    pn))
-
-(defun js2-auto-insert-semicolon (pn)
-  (let* ((tt (js2-get-token))
-         (pos (js2-node-pos pn)))
-      (cond
-       ((= tt js2-SEMI)
-        ;; extend the node bounds to include the semicolon.
-        (setf (js2-node-len pn) (- (js2-current-token-end) pos)))
-       ((memq tt js2-autoinsert-semi-and-warn)
-        (js2-unget-token) ; Not ';', do not consume.
-        ;; Autoinsert ;
-        (js2-parse-warn-missing-semi pos (js2-node-end pn)))
-       (t
-        (if (not (js2-token-follows-eol-p (js2-current-token)))
-            ;; Report error if no EOL or autoinsert ';' otherwise
-            (js2-report-error "msg.no.semi.stmt")
-          (js2-parse-warn-missing-semi pos (js2-node-end pn)))
-        (js2-unget-token) ; Not ';', do not consume.
-        ))))
-
-(defun js2-parse-condition ()
-  "Parse a parenthesized boolean expression, e.g. in an if- or while-stmt.
-The parens are discarded and the expression node is returned.
-The `pos' field of the return value is set to an absolute position
-that must be fixed up by the caller.
-Return value is a list (EXPR LP RP), with absolute paren positions."
-  (let (pn lp rp)
-    (if (js2-must-match js2-LP "msg.no.paren.cond")
-        (setq lp (js2-current-token-beg)))
-    (setq pn (js2-parse-expr))
-    (if (js2-must-match js2-RP "msg.no.paren.after.cond")
-        (setq rp (js2-current-token-beg)))
-    ;; Report strict warning on code like "if (a = 7) ..."
-    (if (and js2-strict-cond-assign-warning
-             (js2-assign-node-p pn))
-        (js2-add-strict-warning "msg.equal.as.assign" nil
-                                (js2-node-pos pn)
-                                (+ (js2-node-pos pn)
-                                   (js2-node-len pn))))
-    (list pn lp rp)))
-
-(defun js2-parse-if ()
-  "Parser for if-statement.  Last matched token must be js2-IF."
-  (let ((pos (js2-current-token-beg))
-        cond if-true if-false else-pos end pn)
-    (setq cond (js2-parse-condition)
-          if-true (js2-parse-statement)
-          if-false (if (js2-match-token js2-ELSE)
-                       (progn
-                         (setq else-pos (- (js2-current-token-beg) pos))
-                         (js2-parse-statement)))
-          end (js2-node-end (or if-false if-true))
-          pn (make-js2-if-node :pos pos
-                               :len (- end pos)
-                               :condition (car cond)
-                               :then-part if-true
-                               :else-part if-false
-                               :else-pos else-pos
-                               :lp (js2-relpos (cl-second cond) pos)
-                               :rp (js2-relpos (cl-third cond) pos)))
-    (js2-node-add-children pn (car cond) if-true if-false)
-    pn))
-
-(defun js2-parse-import ()
-  "Parse import statement. The current token must be js2-IMPORT."
-  (unless (js2-ast-root-p js2-current-scope)
-    (js2-report-error "msg.mod.import.decl.at.top.level"))
-  (let ((beg (js2-current-token-beg)))
-    (cond ((js2-match-token js2-STRING)
-           (make-js2-import-node
-            :pos beg
-            :len (- (js2-current-token-end) beg)
-            :module-id (js2-current-token-string)))
-          (t
-           (let* ((import-clause (js2-parse-import-clause))
-                  (from-clause (and import-clause (js2-parse-from-clause)))
-                  (module-id (when from-clause (js2-from-clause-node-module-id from-clause)))
-                  (node (make-js2-import-node
-                         :pos beg
-                         :len (- (js2-current-token-end) beg)
-                         :import import-clause
-                         :from from-clause
-                         :module-id module-id)))
-             (when import-clause
-               (js2-node-add-children node import-clause))
-             (when from-clause
-               (js2-node-add-children node from-clause))
-             node)))))
-
-(defun js2-parse-import-clause ()
-  "Parse the bindings in an import statement.
-This can take many forms:
-
-ImportedDefaultBinding -> 'foo'
-NameSpaceImport -> '* as lib'
-NamedImports -> '{foo as bar, bang}'
-ImportedDefaultBinding , NameSpaceImport -> 'foo, * as lib'
-ImportedDefaultBinding , NamedImports -> 'foo, {bar, baz as bif}'
-
-Try to match namespace imports and named imports first because nothing can
-come after them. If it is an imported default binding, then it could have named
-imports or a namespace import that follows it.
-"
-  (let* ((beg (js2-current-token-beg))
-         (clause (make-js2-import-clause-node
-                  :pos beg))
-         (children (list)))
-    (cond
-     ((js2-match-token js2-MUL)
-      (let ((ns-import (js2-parse-namespace-import)))
-        (when ns-import
-          (let ((name-node (js2-namespace-import-node-name ns-import)))
-            (js2-define-symbol
-             js2-LET (js2-name-node-name name-node) name-node t))
-          (setf (js2-import-clause-node-namespace-import clause) ns-import)
-          (push ns-import children))))
-     ((js2-match-token js2-LC)
-      (let ((imports (js2-parse-export-bindings t)))
-        (setf (js2-import-clause-node-named-imports clause) imports)
-        (dolist (import imports)
-          (push import children)
-          (let ((name-node (js2-export-binding-node-local-name import)))
-            (when name-node
-              (js2-define-symbol
-               js2-LET (js2-name-node-name name-node) name-node t))))))
-     ((= (js2-peek-token) js2-NAME)
-      (let ((binding (js2-maybe-parse-export-binding t)))
-        (let ((node-name (js2-export-binding-node-local-name binding)))
-          (js2-define-symbol js2-LET (js2-name-node-name node-name) node-name t))
-        (setf (js2-import-clause-node-default-binding clause) binding)
-        (push binding children))
-      (when (js2-match-token js2-COMMA)
-        (cond
-         ((js2-match-token js2-MUL)
-          (let ((ns-import (js2-parse-namespace-import)))
-            (let ((name-node (js2-namespace-import-node-name ns-import)))
-              (js2-define-symbol
-               js2-LET (js2-name-node-name name-node) name-node t))
-            (setf (js2-import-clause-node-namespace-import clause) ns-import)
-            (push ns-import children)))
-         ((js2-match-token js2-LC)
-          (let ((imports (js2-parse-export-bindings t)))
-            (setf (js2-import-clause-node-named-imports clause) imports)
-            (dolist (import imports)
-              (push import children)
-              (let ((name-node (js2-export-binding-node-local-name import)))
-                (when name-node
-                  (js2-define-symbol
-                   js2-LET (js2-name-node-name name-node) name-node t))))))
-         (t (js2-report-error "msg.syntax")))))
-     (t (js2-report-error "msg.mod.declaration.after.import")))
-    (setf (js2-node-len clause) (- (js2-current-token-end) beg))
-    (apply #'js2-node-add-children clause children)
-    clause))
-
-(defun js2-parse-namespace-import ()
-  "Parse a namespace import expression such as  '* as bar'.
-The current token must be js2-MUL."
-  (let ((beg (js2-current-token-beg)))
-    (cond
-      ((js2-match-contextual-kwd "as")
-       (when (js2-must-match-prop-name "msg.syntax")
-         (let ((node (make-js2-namespace-import-node
-                      :pos beg
-                      :len (- (js2-current-token-end) beg)
-                      :name (make-js2-name-node
-                             :pos (js2-current-token-beg)
-                             :len (- (js2-current-token-end)
-                                     (js2-current-token-beg))
-                             :name (js2-current-token-string)))))
-           (js2-node-add-children node (js2-namespace-import-node-name node))
-           node)))
-      (t
-       (js2-unget-token)
-       (js2-report-error "msg.syntax")
-       nil))))
-
-
-(defun js2-parse-from-clause ()
-  "Parse the from clause in an import or export statement. E.g. from 'src/lib'"
-  (if (js2-match-contextual-kwd "from")
-      (let ((beg (js2-current-token-beg)))
-        (cond
-         ((js2-match-token js2-STRING)
-          (make-js2-from-clause-node
-           :pos beg
-           :len (- (js2-current-token-end) beg)
-           :module-id (js2-current-token-string)
-           :metadata-p nil))
-         ((js2-match-token js2-THIS)
-          (when (js2-must-match-name "msg.mod.spec.after.from")
-            (if (equal "module" (js2-current-token-string))
-                (make-js2-from-clause-node
-                 :pos beg
-                 :len (- (js2-current-token-end) beg)
-                 :module-id "this"
-                 :metadata-p t)
-              (js2-unget-token)
-              (js2-unget-token)
-              (js2-report-error "msg.mod.spec.after.from")
-              nil)))
-         (t (js2-report-error "msg.mod.spec.after.from") nil)))
-    (js2-report-error "msg.mod.from.after.import.spec.set")
-    nil))
-
-(defun js2-parse-export-bindings (&optional import-p)
-  "Parse a list of export binding expressions such as {}, {foo, bar}, and
-{foo as bar, baz as bang}. The current token must be
-js2-LC. Return a lisp list of js2-export-binding-node"
-  (let ((bindings (list)))
-    (while
-        (let ((binding (js2-maybe-parse-export-binding import-p)))
-          (when binding
-            (push binding bindings))
-          (js2-match-token js2-COMMA)))
-    (when (js2-must-match js2-RC (if import-p
-                                     "msg.mod.rc.after.import.spec.list"
-                                   "msg.mod.rc.after.export.spec.list"))
-      (reverse bindings))))
-
-(defun js2-maybe-parse-export-binding (&optional import-p)
-  "Attempt to parse a binding expression found inside an import/export statement.
-This can take the form of either as single js2-NAME token as in 'foo' or as in a
-rebinding expression 'bar as foo'. If it matches, it will return an instance of
-js2-export-binding-node and consume all the tokens. If it does not match, it
-consumes no tokens."
-  (let ((extern-name (when (js2-match-prop-name) (js2-current-token-string)))
-        (beg (js2-current-token-beg))
-        (extern-name-len (js2-current-token-len))
-        (is-reserved-name (or (= (js2-current-token-type) js2-RESERVED)
-                              (aref js2-kwd-tokens (js2-current-token-type)))))
-    (if extern-name
-        (if (js2-match-contextual-kwd "as")
-            (let ((name
-                   (or
-                    (and (js2-match-token js2-DEFAULT) "default")
-                    (and (js2-match-token js2-NAME) (js2-current-token-string)))))
-              (if name
-                  (let ((node (make-js2-export-binding-node
-                               :pos beg
-                               :len (- (js2-current-token-end) beg)
-                               :local-name (make-js2-name-node
-                                            :name name
-                                            :pos (js2-current-token-beg)
-                                            :len (js2-current-token-len))
-                               :extern-name (make-js2-name-node
-                                             :name extern-name
-                                             :pos beg
-                                             :len extern-name-len))))
-                    (js2-node-add-children
-                     node
-                     (js2-export-binding-node-local-name node)
-                     (js2-export-binding-node-extern-name node))
-                    (if import-p
-                        (js2-set-face (js2-current-token-beg) (js2-current-token-end)
-                                      'font-lock-variable-name-face 'record))
-                    node)
-                (js2-unget-token)
-                nil))
-          (let* ((name-node (make-js2-name-node
-                             :name (js2-current-token-string)
-                             :pos (js2-current-token-beg)
-                             :len (js2-current-token-len)))
-                 (node (make-js2-export-binding-node
-                        :pos (js2-current-token-beg)
-                        :len (js2-current-token-len)
-                        :local-name name-node
-                        :extern-name name-node)))
-            (when is-reserved-name
-              (js2-report-error "msg.mod.as.after.reserved.word" extern-name))
-            (js2-node-add-children node name-node)
-            (if import-p
-                (js2-set-face (js2-current-token-beg) (js2-current-token-end)
-                              'font-lock-variable-name-face 'record))
-            node))
-      nil)))
-
-(defun js2-parse-switch ()
-  "Parser for switch-statement.  Last matched token must be js2-SWITCH."
-  (let ((pos (js2-current-token-beg))
-        tt pn discriminant has-default case-expr case-node
-        case-pos cases stmt lp)
-    (if (js2-must-match js2-LP "msg.no.paren.switch")
-        (setq lp (js2-current-token-beg)))
-    (setq discriminant (js2-parse-expr)
-          pn (make-js2-switch-node :discriminant discriminant
-                                   :pos pos
-                                   :lp (js2-relpos lp pos)))
-    (js2-node-add-children pn discriminant)
-    (js2-enter-switch pn)
-    (unwind-protect
-        (progn
-          (if (js2-must-match js2-RP "msg.no.paren.after.switch")
-              (setf (js2-switch-node-rp pn) (- (js2-current-token-beg) pos)))
-          (js2-must-match js2-LC "msg.no.brace.switch")
-          (catch 'break
-            (while t
-              (setq tt (js2-next-token)
-                    case-pos (js2-current-token-beg))
-              (cond
-               ((= tt js2-RC)
-                (setf (js2-node-len pn) (- (js2-current-token-end) pos))
-                (throw 'break nil))  ; done
-               ((= tt js2-CASE)
-                (setq case-expr (js2-parse-expr))
-                (js2-must-match js2-COLON "msg.no.colon.case"))
-               ((= tt js2-DEFAULT)
-                (if has-default
-                    (js2-report-error "msg.double.switch.default"))
-                (setq has-default t
-                      case-expr nil)
-                (js2-must-match js2-COLON "msg.no.colon.case"))
-               (t
-                (js2-report-error "msg.bad.switch")
-                (throw 'break nil)))
-              (setq case-node (make-js2-case-node :pos case-pos
-                                                  :len (- (js2-current-token-end) case-pos)
-                                                  :expr case-expr))
-              (js2-node-add-children case-node case-expr)
-              (while (and (/= (setq tt (js2-peek-token)) js2-RC)
-                          (/= tt js2-CASE)
-                          (/= tt js2-DEFAULT)
-                          (/= tt js2-EOF))
-                (setf stmt (js2-parse-statement)
-                      (js2-node-len case-node) (- (js2-node-end stmt) case-pos))
-                (js2-block-node-push case-node stmt))
-              (push case-node cases)))
-          ;; add cases last, as pushing reverses the order to be correct
-          (dolist (kid cases)
-            (js2-node-add-children pn kid)
-            (push kid (js2-switch-node-cases pn)))
-          pn)  ; return value
-      (js2-exit-switch))))
-
-(defun js2-parse-while ()
-  "Parser for while-statement.  Last matched token must be js2-WHILE."
-  (let ((pos (js2-current-token-beg))
-        (pn (make-js2-while-node))
-        cond body)
-    (js2-enter-loop pn)
-    (unwind-protect
-        (progn
-          (setf cond (js2-parse-condition)
-                (js2-while-node-condition pn) (car cond)
-                body (js2-parse-statement)
-                (js2-while-node-body pn) body
-                (js2-node-len pn) (- (js2-node-end body) pos)
-                (js2-while-node-lp pn) (js2-relpos (cl-second cond) pos)
-                (js2-while-node-rp pn) (js2-relpos (cl-third cond) pos))
-          (js2-node-add-children pn body (car cond)))
-      (js2-exit-loop))
-    pn))
-
-(defun js2-parse-do ()
-  "Parser for do-statement.  Last matched token must be js2-DO."
-  (let ((pos (js2-current-token-beg))
-        (pn (make-js2-do-node))
-        cond body end)
-    (js2-enter-loop pn)
-    (unwind-protect
-        (progn
-          (setq body (js2-parse-statement))
-          (js2-must-match js2-WHILE "msg.no.while.do")
-          (setf (js2-do-node-while-pos pn) (- (js2-current-token-beg) pos)
-                cond (js2-parse-condition)
-                (js2-do-node-condition pn) (car cond)
-                (js2-do-node-body pn) body
-                end js2-ts-cursor
-                (js2-do-node-lp pn) (js2-relpos (cl-second cond) pos)
-                (js2-do-node-rp pn) (js2-relpos (cl-third cond) pos))
-          (js2-node-add-children pn (car cond) body))
-      (js2-exit-loop))
-    ;; Always auto-insert semicolon to follow SpiderMonkey:
-    ;; It is required by ECMAScript but is ignored by the rest of
-    ;; world; see bug 238945
-    (if (js2-match-token js2-SEMI)
-        (setq end js2-ts-cursor))
-    (setf (js2-node-len pn) (- end pos))
-    pn))
-
-(defun js2-parse-export ()
-  "Parse an export statement.
-The Last matched token must be js2-EXPORT. Currently, the 'default' and 'expr'
-expressions should only be either hoistable expressions (function or generator)
-or assignment expressions, but there is no checking to enforce that and so it
-will parse without error a small subset of
-invalid export statements."
-  (unless (js2-ast-root-p js2-current-scope)
-    (js2-report-error "msg.mod.export.decl.at.top.level"))
-  (let ((beg (js2-current-token-beg))
-        (children (list))
-        exports-list from-clause declaration default)
-    (cond
-     ((js2-match-token js2-MUL)
-      (setq from-clause (js2-parse-from-clause))
-      (when from-clause
-        (push from-clause children)))
-     ((js2-match-token js2-LC)
-      (setq exports-list (js2-parse-export-bindings))
-      (when exports-list
-        (dolist (export exports-list)
-          (push export children)))
-      (when (js2-match-contextual-kwd "from")
-        (js2-unget-token)
-        (setq from-clause (js2-parse-from-clause))))
-     ((js2-match-token js2-DEFAULT)
-      (setq default (cond ((js2-match-token js2-CLASS)
-                           (if (eq (js2-peek-token) js2-NAME)
-                               (js2-parse-class-stmt)
-                             (js2-parse-class-expr)))
-                          ((js2-match-token js2-NAME)
-                           (if (js2-match-async-function)
-                               (if (eq (js2-peek-token) js2-NAME)
-                                   (js2-parse-async-function-stmt)
-                                 (js2-parse-function-expr t))
-                             (js2-unget-token)
-                             (js2-parse-expr)))
-                          ((js2-match-token js2-FUNCTION)
-                           (if (eq (js2-peek-token) js2-NAME)
-                               (js2-parse-function-stmt)
-                             (js2-parse-function-expr)))
-                          (t (js2-parse-expr)))))
-     ((or (js2-match-token js2-VAR) (js2-match-token js2-CONST) (js2-match-token js2-LET))
-      (setq declaration (js2-parse-variables (js2-current-token-type) (js2-current-token-beg))))
-     ((js2-match-token js2-CLASS)
-      (setq declaration (js2-parse-class-stmt)))
-     ((js2-match-token js2-NAME)
-      (setq declaration
-            (if (js2-match-async-function)
-                (js2-parse-async-function-stmt)
-              (js2-unget-token)
-              (js2-parse-expr))))
-     ((js2-match-token js2-FUNCTION)
-      (setq declaration (js2-parse-function-stmt)))
-     (t
-      (setq declaration (js2-parse-expr))))
-    (when from-clause
-      (push from-clause children))
-    (when declaration
-      (push declaration children)
-      (when (not (or (js2-function-node-p declaration)
-                     (js2-class-node-p declaration)))
-        (js2-auto-insert-semicolon declaration)))
-    (when default
-      (push default children)
-      (when (not (or (js2-function-node-p default)
-                     (js2-class-node-p default)))
-        (js2-auto-insert-semicolon default)))
-    (let ((node (make-js2-export-node
-                  :pos beg
-                  :len (- (js2-current-token-end) beg)
-                  :exports-list exports-list
-                  :from-clause from-clause
-                  :declaration declaration
-                  :default default)))
-      (apply #'js2-node-add-children node children)
-      node)))
-
-(defun js2-parse-for ()
-  "Parse a for, for-in or for each-in statement.
-Last matched token must be js2-FOR."
-  (let ((for-pos (js2-current-token-beg))
-        (tmp-scope (make-js2-scope))
-        pn is-for-each is-for-in-or-of is-for-of
-        in-pos each-pos tmp-pos
-        init  ; Node init is also foo in 'foo in object'.
-        cond  ; Node cond is also object in 'foo in object'.
-        incr  ; 3rd section of for-loop initializer.
-        body tt lp rp)
-    ;; See if this is a for each () instead of just a for ()
-    (when (js2-match-token js2-NAME)
-      (if (string= "each" (js2-current-token-string))
-          (progn
-            (setq is-for-each t
-                  each-pos (- (js2-current-token-beg) for-pos)) ; relative
-            (js2-record-face 'font-lock-keyword-face))
-        (js2-report-error "msg.no.paren.for")))
-    (if (js2-must-match js2-LP "msg.no.paren.for")
-        (setq lp (- (js2-current-token-beg) for-pos)))
-    (setq tt (js2-get-token))
-    ;; Capture identifiers inside parens.  We can't create the node
-    ;; (and use it as the current scope) until we know its type.
-    (js2-push-scope tmp-scope)
-    (unwind-protect
-        (progn
-          ;; parse init clause
-          (let ((js2-in-for-init t))  ; set as dynamic variable
-            (cond
-             ((= tt js2-SEMI)
-              (js2-unget-token)
-              (setq init (make-js2-empty-expr-node)))
-             ((or (= tt js2-VAR) (= tt js2-LET) (= tt js2-CONST))
-              (setq init (js2-parse-variables tt (js2-current-token-beg))))
-             (t
-              (js2-unget-token)
-              (setq init (js2-parse-expr)))))
-          (if (or (js2-match-token js2-IN)
-                  (and (>= js2-language-version 200)
-                       (js2-match-contextual-kwd "of")
-                       (setq is-for-of t)))
-              (setq is-for-in-or-of t
-                    in-pos (- (js2-current-token-beg) for-pos)
-                    ;; scope of iteration target object is not the scope we've created above.
-                    ;; stash current scope temporary.
-                    cond (let ((js2-current-scope (js2-scope-parent-scope js2-current-scope)))
-                           (js2-parse-expr)))  ; object over which we're iterating
-            ;; else ordinary for loop - parse cond and incr
-            (js2-must-match js2-SEMI "msg.no.semi.for")
-            (setq cond (if (= (js2-peek-token) js2-SEMI)
-                           (make-js2-empty-expr-node) ; no loop condition
-                         (js2-parse-expr)))
-            (js2-must-match js2-SEMI "msg.no.semi.for.cond")
-            (setq tmp-pos (js2-current-token-end)
-                  incr (if (= (js2-peek-token) js2-RP)
-                           (make-js2-empty-expr-node :pos tmp-pos)
-                         (js2-parse-expr)))))
-      (js2-pop-scope))
-    (if (js2-must-match js2-RP "msg.no.paren.for.ctrl")
-        (setq rp (- (js2-current-token-beg) for-pos)))
-    (if (not is-for-in-or-of)
-        (setq pn (make-js2-for-node :init init
-                                    :condition cond
-                                    :update incr
-                                    :lp lp
-                                    :rp rp))
-      ;; cond could be null if 'in obj' got eaten by the init node.
-      (if (js2-infix-node-p init)
-          ;; it was (foo in bar) instead of (var foo in bar)
-          (setq cond (js2-infix-node-right init)
-                init (js2-infix-node-left init))
-        (if (and (js2-var-decl-node-p init)
-                 (> (length (js2-var-decl-node-kids init)) 1))
-            (js2-report-error "msg.mult.index")))
-      (setq pn (make-js2-for-in-node :iterator init
-                                     :object cond
-                                     :in-pos in-pos
-                                     :foreach-p is-for-each
-                                     :each-pos each-pos
-                                     :forof-p is-for-of
-                                     :lp lp
-                                     :rp rp)))
-    ;; Transplant the declarations.
-    (setf (js2-scope-symbol-table pn)
-          (js2-scope-symbol-table tmp-scope))
-    (unwind-protect
-        (progn
-          (js2-enter-loop pn)
-          ;; We have to parse the body -after- creating the loop node,
-          ;; so that the loop node appears in the js2-loop-set, allowing
-          ;; break/continue statements to find the enclosing loop.
-          (setf body (js2-parse-statement)
-                (js2-loop-node-body pn) body
-                (js2-node-pos pn) for-pos
-                (js2-node-len pn) (- (js2-node-end body) for-pos))
-          (js2-node-add-children pn init cond incr body))
-      ;; finally
-      (js2-exit-loop))
-    pn))
-
-(defun js2-parse-try ()
-  "Parse a try statement.  Last matched token must be js2-TRY."
-  (let ((try-pos (js2-current-token-beg))
-        try-end
-        try-block
-        catch-blocks
-        finally-block
-        saw-default-catch
-        peek)
-    (if (/= (js2-peek-token) js2-LC)
-        (js2-report-error "msg.no.brace.try"))
-    (setq try-block (js2-parse-statement)
-          try-end (js2-node-end try-block)
-          peek (js2-peek-token))
-    (cond
-     ((= peek js2-CATCH)
-      (while (js2-match-token js2-CATCH)
-        (let* ((catch-pos (js2-current-token-beg))
-               (catch-node (make-js2-catch-node :pos catch-pos))
-               param
-               guard-kwd
-               catch-cond
-               lp rp)
-          (if saw-default-catch
-              (js2-report-error "msg.catch.unreachable"))
-          (if (js2-must-match js2-LP "msg.no.paren.catch")
-              (setq lp (- (js2-current-token-beg) catch-pos)))
-          (js2-push-scope catch-node)
-          (let ((tt (js2-peek-token)))
-            (cond
-             ;; Destructuring pattern:
-             ;;     catch ({ message, file }) { ... }
-             ((or (= tt js2-LB) (= tt js2-LC))
-              (js2-get-token)
-              (setq param (js2-parse-destruct-primary-expr))
-              (js2-define-destruct-symbols param js2-LET nil))
-             ;; Simple name.
-             (t
-              (js2-must-match-name "msg.bad.catchcond")
-              (setq param (js2-create-name-node))
-              (js2-define-symbol js2-LET (js2-current-token-string) param)
-              (js2-check-strict-identifier param))))
-          ;; Catch condition.
-          (if (js2-match-token js2-IF)
-              (setq guard-kwd (- (js2-current-token-beg) catch-pos)
-                    catch-cond (js2-parse-expr))
-            (setq saw-default-catch t))
-          (if (js2-must-match js2-RP "msg.bad.catchcond")
-              (setq rp (- (js2-current-token-beg) catch-pos)))
-          (js2-must-match js2-LC "msg.no.brace.catchblock")
-          (js2-parse-statements catch-node)
-          (if (js2-must-match js2-RC "msg.no.brace.after.body")
-              (setq try-end (js2-current-token-end)))
-          (js2-pop-scope)
-          (setf (js2-node-len catch-node) (- try-end catch-pos)
-                (js2-catch-node-param catch-node) param
-                (js2-catch-node-guard-expr catch-node) catch-cond
-                (js2-catch-node-guard-kwd catch-node) guard-kwd
-                (js2-catch-node-lp catch-node) lp
-                (js2-catch-node-rp catch-node) rp)
-          (js2-node-add-children catch-node param catch-cond)
-          (push catch-node catch-blocks))))
-     ((/= peek js2-FINALLY)
-      (js2-must-match js2-FINALLY "msg.try.no.catchfinally"
-                      (js2-node-pos try-block)
-                      (- (setq try-end (js2-node-end try-block))
-                         (js2-node-pos try-block)))))
-    (when (js2-match-token js2-FINALLY)
-      (let ((finally-pos (js2-current-token-beg))
-            (block (js2-parse-statement)))
-        (setq try-end (js2-node-end block)
-              finally-block (make-js2-finally-node :pos finally-pos
-                                                   :len (- try-end finally-pos)
-                                                   :body block))
-        (js2-node-add-children finally-block block)))
-    (let ((pn (make-js2-try-node :pos try-pos
-                                 :len (- try-end try-pos)
-                                 :try-block try-block
-                                 :finally-block finally-block)))
-      (js2-node-add-children pn try-block finally-block)
-      ;; Push them onto the try-node, which reverses and corrects their order.
-      (dolist (cb catch-blocks)
-        (js2-node-add-children pn cb)
-        (push cb (js2-try-node-catch-clauses pn)))
-      pn)))
-
-(defun js2-parse-throw ()
-  "Parser for throw-statement.  Last matched token must be js2-THROW."
-  (let ((pos (js2-current-token-beg))
-        expr pn)
-    (if (= (js2-peek-token-or-eol) js2-EOL)
-        ;; ECMAScript does not allow new lines before throw expression,
-        ;; see bug 256617
-        (js2-report-error "msg.bad.throw.eol"))
-    (setq expr (js2-parse-expr)
-          pn (make-js2-throw-node :pos pos
-                                  :len (- (js2-node-end expr) pos)
-                                  :expr expr))
-    (js2-node-add-children pn expr)
-    pn))
-
-(defun js2-match-jump-label-name (label-name)
-  "If break/continue specified a label, return that label's labeled stmt.
-Returns the corresponding `js2-labeled-stmt-node', or if LABEL-NAME
-does not match an existing label, reports an error and returns nil."
-  (let ((bundle (cdr (assoc label-name js2-label-set))))
-    (if (null bundle)
-        (js2-report-error "msg.undef.label"))
-    bundle))
-
-(defun js2-parse-break ()
-  "Parser for break-statement.  Last matched token must be js2-BREAK."
-  (let ((pos (js2-current-token-beg))
-        (end (js2-current-token-end))
-        break-target ; statement to break from
-        break-label  ; in "break foo", name-node representing the foo
-        labels       ; matching labeled statement to break to
-        pn)
-    (when (eq (js2-peek-token-or-eol) js2-NAME)
-      (js2-get-token)
-      (setq break-label (js2-create-name-node)
-            end (js2-node-end break-label)
-            ;; matchJumpLabelName only matches if there is one
-            labels (js2-match-jump-label-name (js2-current-token-string))
-            break-target (if labels (car (js2-labeled-stmt-node-labels labels)))))
-    (unless (or break-target break-label)
-      ;; no break target specified - try for innermost enclosing loop/switch
-      (if (null js2-loop-and-switch-set)
-          (unless break-label
-            (js2-report-error "msg.bad.break" nil pos (length "break")))
-        (setq break-target (car js2-loop-and-switch-set))))
-    (setq pn (make-js2-break-node :pos pos
-                                  :len (- end pos)
-                                  :label break-label
-                                  :target break-target))
-    (js2-node-add-children pn break-label)  ; but not break-target
-    pn))
-
-(defun js2-parse-continue ()
-  "Parser for continue-statement.  Last matched token must be js2-CONTINUE."
-  (let ((pos (js2-current-token-beg))
-        (end (js2-current-token-end))
-        label   ; optional user-specified label, a `js2-name-node'
-        labels  ; current matching labeled stmt, if any
-        target  ; the `js2-loop-node' target of this continue stmt
-        pn)
-    (when (= (js2-peek-token-or-eol) js2-NAME)
-      (js2-get-token)
-      (setq label (js2-create-name-node)
-            end (js2-node-end label)
-            ;; matchJumpLabelName only matches if there is one
-            labels (js2-match-jump-label-name (js2-current-token-string))))
-    (cond
-     ((null labels)  ; no current label to go to
-      (if (null js2-loop-set)  ; no loop to continue to
-          (js2-report-error "msg.continue.outside" nil pos
-                            (length "continue"))
-        (setq target (car js2-loop-set))))  ; innermost enclosing loop
-     (t
-      (if (js2-loop-node-p (js2-labeled-stmt-node-stmt labels))
-          (setq target (js2-labeled-stmt-node-stmt labels))
-        (js2-report-error "msg.continue.nonloop" nil pos (- end pos)))))
-    (setq pn (make-js2-continue-node :pos pos
-                                     :len (- end pos)
-                                     :label label
-                                     :target target))
-    (js2-node-add-children pn label)  ; but not target - it's not our child
-    pn))
-
-(defun js2-parse-with ()
-  "Parser for with-statement.  Last matched token must be js2-WITH."
-  (when js2-in-use-strict-directive
-    (js2-report-error "msg.no.with.strict"))
-  (let ((pos (js2-current-token-beg))
-        obj body pn lp rp)
-    (if (js2-must-match js2-LP "msg.no.paren.with")
-        (setq lp (js2-current-token-beg)))
-    (setq obj (js2-parse-expr))
-    (if (js2-must-match js2-RP "msg.no.paren.after.with")
-        (setq rp (js2-current-token-beg)))
-    (let ((js2-nesting-of-with (1+ js2-nesting-of-with)))
-        (setq body (js2-parse-statement)))
-    (setq pn (make-js2-with-node :pos pos
-                                 :len (- (js2-node-end body) pos)
-                                 :object obj
-                                 :body body
-                                 :lp (js2-relpos lp pos)
-                                 :rp (js2-relpos rp pos)))
-    (js2-node-add-children pn obj body)
-    pn))
-
-(defun js2-parse-const-var ()
-  "Parser for var- or const-statement.
-Last matched token must be js2-CONST or js2-VAR."
-  (let ((tt (js2-current-token-type))
-        (pos (js2-current-token-beg))
-        expr pn)
-    (setq expr (js2-parse-variables tt (js2-current-token-beg))
-          pn (make-js2-expr-stmt-node :pos pos
-                                      :len (- (js2-node-end expr) pos)
-                                      :expr expr))
-    (js2-node-add-children pn expr)
-    pn))
-
-(defun js2-wrap-with-expr-stmt (pos expr &optional add-child)
-  (let ((pn (make-js2-expr-stmt-node :pos pos
-                                     :len (js2-node-len expr)
-                                     :type (if (js2-inside-function)
-                                               js2-EXPR_VOID
-                                             js2-EXPR_RESULT)
-                                     :expr expr)))
-    (if add-child
-        (js2-node-add-children pn expr))
-    pn))
-
-(defun js2-parse-let-stmt ()
-  "Parser for let-statement.  Last matched token must be js2-LET."
-  (let ((pos (js2-current-token-beg))
-        expr pn)
-    (if (= (js2-peek-token) js2-LP)
-        ;; let expression in statement context
-        (setq expr (js2-parse-let pos 'statement)
-              pn (js2-wrap-with-expr-stmt pos expr t))
-      ;; else we're looking at a statement like let x=6, y=7;
-      (setf expr (js2-parse-variables js2-LET pos)
-            pn (js2-wrap-with-expr-stmt pos expr t)
-            (js2-node-type pn) js2-EXPR_RESULT))
-    pn))
-
-(defun js2-parse-ret-yield ()
-  (js2-parse-return-or-yield (js2-current-token-type) nil))
-
-(defconst js2-parse-return-stmt-enders
-  (list js2-SEMI js2-RC js2-EOF js2-EOL js2-ERROR js2-RB js2-RP))
-
-(defsubst js2-now-all-set (before after mask)
-  "Return whether or not the bits in the mask have changed to all set.
-BEFORE is bits before change, AFTER is bits after change, and MASK is
-the mask for bits.  Returns t if all the bits in the mask are set in AFTER
-but not BEFORE."
-  (and (/= (logand before mask) mask)
-       (= (logand after mask) mask)))
-
-(defun js2-parse-return-or-yield (tt expr-context)
-  (let* ((pos (js2-current-token-beg))
-         (end (js2-current-token-end))
-         (before js2-end-flags)
-         (inside-function (js2-inside-function))
-         (gen-type (and inside-function (js2-function-node-generator-type
-                                         js2-current-script-or-fn)))
-         e ret name yield-star-p)
-    (unless inside-function
-      (js2-report-error (if (eq tt js2-RETURN)
-                            "msg.bad.return"
-                          "msg.bad.yield")))
-    (when (and inside-function
-               (eq gen-type 'STAR)
-               (js2-match-token js2-MUL))
-      (setq yield-star-p t))
-    ;; This is ugly, but we don't want to require a semicolon.
-    (unless (memq (js2-peek-token-or-eol) js2-parse-return-stmt-enders)
-      (setq e (if (eq gen-type 'STAR)
-                  (js2-parse-assign-expr)
-                (js2-parse-expr))
-            end (js2-node-end e)))
-    (cond
-     ((eq tt js2-RETURN)
-      (js2-set-flag js2-end-flags (if (null e)
-                                      js2-end-returns
-                                    js2-end-returns-value))
-      (setq ret (make-js2-return-node :pos pos
-                                      :len (- end pos)
-                                      :retval e))
-      (js2-node-add-children ret e)
-      ;; See if we need a strict mode warning.
-      ;; TODO:  The analysis done by `js2-has-consistent-return-usage' is
-      ;; more thorough and accurate than this before/after flag check.
-      ;; E.g. if there's a finally-block that always returns, we shouldn't
-      ;; show a warning generated by inconsistent returns in the catch blocks.
-      ;; Basically `js2-has-consistent-return-usage' needs to keep more state,
-      ;; so we know which returns/yields to highlight, and we should get rid of
-      ;; all the checking in `js2-parse-return-or-yield'.
-      (if (and js2-strict-inconsistent-return-warning
-               (js2-now-all-set before js2-end-flags
-                                (logior js2-end-returns js2-end-returns-value)))
-          (js2-add-strict-warning "msg.return.inconsistent" nil pos end)))
-     ((eq gen-type 'COMPREHENSION)
-      ;; FIXME: We should probably switch to saving and using lastYieldOffset,
-      ;; like SpiderMonkey does.
-      (js2-report-error "msg.syntax" nil pos 5))
-     (t
-      (setq ret (make-js2-yield-node :pos pos
-                                     :len (- end pos)
-                                     :value e
-                                     :star-p yield-star-p))
-      (js2-node-add-children ret e)
-      (unless expr-context
-        (setq e ret
-              ret (js2-wrap-with-expr-stmt pos e t))
-      (js2-set-requires-activation)
-      (js2-set-is-generator))))
-    ;; see if we are mixing yields and value returns.
-    (when (and inside-function
-               (js2-flag-set-p js2-end-flags js2-end-returns-value)
-               (eq (js2-function-node-generator-type js2-current-script-or-fn)
-                   'LEGACY))
-      (setq name (js2-function-name js2-current-script-or-fn))
-      (if (zerop (length name))
-          (js2-report-error "msg.anon.generator.returns" nil pos (- end pos))
-        (js2-report-error "msg.generator.returns" name pos (- end pos))))
-    ret))
-
-(defun js2-parse-debugger ()
-  (make-js2-keyword-node :type js2-DEBUGGER))
-
-(defun js2-parse-block ()
-  "Parser for a curly-delimited statement block.
-Last token matched must be `js2-LC'."
-  (let ((pos (js2-current-token-beg))
-        (pn (make-js2-scope)))
-    (js2-push-scope pn)
-    (unwind-protect
-        (progn
-          (js2-parse-statements pn)
-          (js2-must-match js2-RC "msg.no.brace.block")
-          (setf (js2-node-len pn) (- (js2-current-token-end) pos)))
-      (js2-pop-scope))
-    pn))
-
-;; For `js2-ERROR' too, to have a node for error recovery to work on.
-(defun js2-parse-semi ()
-  "Parse a statement or handle an error.
-Current token type is `js2-SEMI' or `js2-ERROR'."
-  (let ((tt (js2-current-token-type)) pos len)
-    (if (eq tt js2-SEMI)
-        (make-js2-empty-expr-node :len 1)
-      (setq pos (js2-current-token-beg)
-            len (- (js2-current-token-end) pos))
-      (js2-report-error "msg.syntax" nil pos len)
-      (make-js2-error-node :pos pos :len len))))
-
-(defun js2-parse-default-xml-namespace ()
-  "Parse a `default xml namespace = <expr>' e4x statement."
-  (let ((pos (js2-current-token-beg))
-        end len expr unary)
-    (js2-must-have-xml)
-    (js2-set-requires-activation)
-    (setq len (- js2-ts-cursor pos))
-    (unless (and (js2-match-token js2-NAME)
-                 (string= (js2-current-token-string) "xml"))
-      (js2-report-error "msg.bad.namespace" nil pos len))
-    (unless (and (js2-match-token js2-NAME)
-                 (string= (js2-current-token-string) "namespace"))
-      (js2-report-error "msg.bad.namespace" nil pos len))
-    (unless (js2-match-token js2-ASSIGN)
-      (js2-report-error "msg.bad.namespace" nil pos len))
-    (setq expr (js2-parse-expr)
-          end (js2-node-end expr)
-          unary (make-js2-unary-node :type js2-DEFAULTNAMESPACE
-                                     :pos pos
-                                     :len (- end pos)
-                                     :operand expr))
-    (js2-node-add-children unary expr)
-    (make-js2-expr-stmt-node :pos pos
-                             :len (- end pos)
-                             :expr unary)))
-
-(defun js2-record-label (label bundle)
-  ;; current token should be colon that `js2-parse-primary-expr' left untouched
-  (js2-get-token)
-  (let ((name (js2-label-node-name label))
-        labeled-stmt
-        dup)
-    (when (setq labeled-stmt (cdr (assoc name js2-label-set)))
-      ;; flag both labels if possible when used in editing mode
-      (if (and js2-parse-ide-mode
-               (setq dup (js2-get-label-by-name labeled-stmt name)))
-          (js2-report-error "msg.dup.label" nil
-                            (js2-node-abs-pos dup) (js2-node-len dup)))
-      (js2-report-error "msg.dup.label" nil
-                        (js2-node-pos label) (js2-node-len label)))
-    (js2-labeled-stmt-node-add-label bundle label)
-    (js2-node-add-children bundle label)
-    ;; Add one reference to the bundle per label in `js2-label-set'
-    (push (cons name bundle) js2-label-set)))
-
-(defun js2-parse-name-or-label ()
-  "Parser for identifier or label.  Last token matched must be js2-NAME.
-Called when we found a name in a statement context.  If it's a label, we gather
-up any following labels and the next non-label statement into a
-`js2-labeled-stmt-node' bundle and return that.  Otherwise we parse an
-expression and return it wrapped in a `js2-expr-stmt-node'."
-  (let ((pos (js2-current-token-beg))
-        expr stmt bundle
-        (continue t))
-    ;; set check for label and call down to `js2-parse-primary-expr'
-    (setq expr (js2-maybe-parse-label))
-    (if (null expr)
-        ;; Parse the non-label expression and wrap with expression stmt.
-        (js2-wrap-with-expr-stmt pos (js2-parse-expr) t)
-      ;; else parsed a label
-      (setq bundle (make-js2-labeled-stmt-node :pos pos))
-      (js2-record-label expr bundle)
-      ;; look for more labels
-      (while (and continue (= (js2-get-token) js2-NAME))
-        (if (setq expr (js2-maybe-parse-label))
-            (js2-record-label expr bundle)
-          (setq expr (js2-parse-expr)
-                stmt (js2-wrap-with-expr-stmt (js2-node-pos expr) expr t)
-                continue nil)
-          (js2-auto-insert-semicolon stmt)))
-      ;; no more labels; now parse the labeled statement
-      (unwind-protect
-            (unless stmt
-              (let ((js2-labeled-stmt bundle))  ; bind dynamically
-                (js2-unget-token)
-                (setq stmt (js2-statement-helper))))
-        ;; remove the labels for this statement from the global set
-        (dolist (label (js2-labeled-stmt-node-labels bundle))
-          (setq js2-label-set (remove label js2-label-set))))
-      (setf (js2-labeled-stmt-node-stmt bundle) stmt
-            (js2-node-len bundle) (- (js2-node-end stmt) pos))
-      (js2-node-add-children bundle stmt)
-      bundle)))
-
-(defun js2-maybe-parse-label ()
-  (cl-assert (= (js2-current-token-type) js2-NAME))
-  (let (label-pos
-        (next-tt (js2-get-token))
-        (label-end (js2-current-token-end)))
-    ;; Do not consume colon, it is used as unwind indicator
-    ;; to return to statementHelper.
-    (js2-unget-token)
-    (if (= next-tt js2-COLON)
-        (prog2
-            (setq label-pos (js2-current-token-beg))
-            (make-js2-label-node :pos label-pos
-                                 :len (- label-end label-pos)
-                                 :name (js2-current-token-string))
-          (js2-set-face label-pos
-                        label-end
-                        'font-lock-variable-name-face 'record))
-      ;; Backtrack from the name token, too.
-      (js2-unget-token)
-      nil)))
-
-(defun js2-parse-expr-stmt ()
-  "Default parser in statement context, if no recognized statement found."
-  (js2-wrap-with-expr-stmt (js2-current-token-beg)
-                           (progn
-                             (js2-unget-token)
-                             (js2-parse-expr)) t))
-
-(defun js2-parse-variables (decl-type pos)
-  "Parse a comma-separated list of variable declarations.
-Could be a 'var', 'const' or 'let' expression, possibly in a for-loop initializer.
-
-DECL-TYPE is a token value: either VAR, CONST, or LET depending on context.
-For 'var' or 'const', the keyword should be the token last scanned.
-
-POS is the position where the node should start. It's sometimes the
-var/const/let keyword, and other times the beginning of the first token
-in the first variable declaration.
-
-Returns the parsed `js2-var-decl-node' expression node."
-  (let* ((result (make-js2-var-decl-node :decl-type decl-type
-                                         :pos pos))
-         destructuring kid-pos tt init name end nbeg nend vi
-         (continue t))
-    ;; Example:
-    ;; var foo = {a: 1, b: 2}, bar = [3, 4];
-    ;; var {b: s2, a: s1} = foo, x = 6, y, [s3, s4] = bar;
-    ;; var {a, b} = baz;
-    (while continue
-      (setq destructuring nil
-            name nil
-            tt (js2-get-token)
-            kid-pos (js2-current-token-beg)
-            end (js2-current-token-end)
-            init nil)
-      (if (or (= tt js2-LB) (= tt js2-LC))
-          ;; Destructuring assignment, e.g., var [a, b] = ...
-          (setq destructuring (js2-parse-destruct-primary-expr)
-                end (js2-node-end destructuring))
-        ;; Simple variable name
-        (js2-unget-token)
-        (when (js2-must-match-name "msg.bad.var")
-          (setq name (js2-create-name-node)
-                nbeg (js2-current-token-beg)
-                nend (js2-current-token-end)
-                end nend)
-          (js2-define-symbol decl-type (js2-current-token-string) name js2-in-for-init)
-          (js2-check-strict-identifier name)))
-      (when (js2-match-token js2-ASSIGN)
-        (setq init (js2-parse-assign-expr)
-              end (js2-node-end init))
-        (js2-record-imenu-functions init name))
-      (when name
-        (js2-set-face nbeg nend (if (js2-function-node-p init)
-                                    'font-lock-function-name-face
-                                  'font-lock-variable-name-face)
-                      'record))
-      (setq vi (make-js2-var-init-node :pos kid-pos
-                                       :len (- end kid-pos)
-                                       :type decl-type))
-      (if destructuring
-          (progn
-            (if (and (null init) (not js2-in-for-init))
-                (js2-report-error "msg.destruct.assign.no.init"))
-            (js2-define-destruct-symbols destructuring
-                                         decl-type
-                                         'font-lock-variable-name-face)
-            (setf (js2-var-init-node-target vi) destructuring))
-        (setf (js2-var-init-node-target vi) name))
-      (setf (js2-var-init-node-initializer vi) init)
-      (js2-node-add-children vi name destructuring init)
-      (js2-block-node-push result vi)
-      (unless (js2-match-token js2-COMMA)
-        (setq continue nil)))
-    (setf (js2-node-len result) (- end pos))
-    result))
-
-(defun js2-parse-let (pos &optional stmt-p)
-  "Parse a let expression or statement.
-A let-expression is of the form `let (vars) expr'.
-A let-statement is of the form `let (vars) {statements}'.
-The third form of let is a variable declaration list, handled
-by `js2-parse-variables'."
-  (let ((pn (make-js2-let-node :pos pos))
-        beg vars body)
-    (if (js2-must-match js2-LP "msg.no.paren.after.let")
-        (setf (js2-let-node-lp pn) (- (js2-current-token-beg) pos)))
-    (js2-push-scope pn)
-    (unwind-protect
-        (progn
-          (setq vars (js2-parse-variables js2-LET (js2-current-token-beg)))
-          (if (js2-must-match js2-RP "msg.no.paren.let")
-              (setf (js2-let-node-rp pn) (- (js2-current-token-beg) pos)))
-          (if (and stmt-p (js2-match-token js2-LC))
-              ;; let statement
-              (progn
-                (setf beg (js2-current-token-beg)  ; position stmt at LC
-                      body (js2-parse-statements))
-                (js2-must-match js2-RC "msg.no.curly.let")
-                (setf (js2-node-len body) (- (js2-current-token-end) beg)
-                      (js2-node-len pn) (- (js2-current-token-end) pos)
-                      (js2-let-node-body pn) body
-                      (js2-node-type pn) js2-LET))
-            ;; let expression
-            (setf body (js2-parse-expr)
-                  (js2-node-len pn) (- (js2-node-end body) pos)
-                  (js2-let-node-body pn) body))
-          (setf (js2-let-node-vars pn) vars)
-          (js2-node-add-children pn vars body))
-      (js2-pop-scope))
-    pn))
-
-(defun js2-define-new-symbol (decl-type name node &optional scope)
-  (js2-scope-put-symbol (or scope js2-current-scope)
-                        name
-                        (make-js2-symbol decl-type name node)))
-
-(defun js2-define-symbol (decl-type name &optional node ignore-not-in-block)
-  "Define a symbol in the current scope.
-If NODE is non-nil, it is the AST node associated with the symbol."
-  (let* ((defining-scope (js2-get-defining-scope js2-current-scope name))
-         (symbol (if defining-scope
-                     (js2-scope-get-symbol defining-scope name)))
-         (sdt (if symbol (js2-symbol-decl-type symbol) -1))
-         (pos (if node (js2-node-abs-pos node)))
-         (len (if node (js2-node-len node))))
-    (cond
-     ((and symbol ; already defined in this block
-           (or (= sdt js2-LET)
-               (= sdt js2-CONST))
-           (eq defining-scope js2-current-scope))
-      (js2-report-error
-       (cond
-        ((= sdt js2-CONST) "msg.const.redecl")
-        ((= sdt js2-LET) "msg.let.redecl")
-        ((= sdt js2-VAR) "msg.var.redecl")
-        ((= sdt js2-FUNCTION) "msg.function.redecl")
-        (t "msg.parm.redecl"))
-       name pos len))
-     ((or (= decl-type js2-LET)
-          (= decl-type js2-CONST))
-      (if (and (= decl-type js2-LET)
-               (not ignore-not-in-block)
-               (or (= (js2-node-type js2-current-scope) js2-IF)
-                   (js2-loop-node-p js2-current-scope)))
-          (js2-report-error "msg.let.decl.not.in.block")
-        (js2-define-new-symbol decl-type name node)))
-     ((or (= decl-type js2-VAR)
-          (= decl-type js2-FUNCTION))
-      (if symbol
-          (if (and js2-strict-var-redeclaration-warning (= sdt js2-VAR))
-              (js2-add-strict-warning "msg.var.redecl" name)
-            (if (and js2-strict-var-hides-function-arg-warning (= sdt js2-LP))
-                (js2-add-strict-warning "msg.var.hides.arg" name)))
-        (js2-define-new-symbol decl-type name node
-                               js2-current-script-or-fn)))
-     ((= decl-type js2-LP)
-      (if symbol
-          ;; must be duplicate parameter. Second parameter hides the
-          ;; first, so go ahead and add the second pararameter
-          (js2-report-warning "msg.dup.parms" name))
-      (js2-define-new-symbol decl-type name node))
-     (t (js2-code-bug)))))
-
-(defun js2-parse-paren-expr-or-generator-comp ()
-  (let ((px-pos (js2-current-token-beg)))
-    (cond
-     ((and (>= js2-language-version 200)
-           (js2-match-token js2-FOR))
-      (js2-parse-generator-comp px-pos))
-     ((and (>= js2-language-version 200)
-           (js2-match-token js2-RP))
-      ;; Not valid expression syntax, but this is valid in an arrow
-      ;; function with no params: () => body.
-      (if (eq (js2-peek-token) js2-ARROW)
-          ;; Return whatever, it will hopefully be rewinded and
-          ;; reparsed when we reach the =>.
-          (make-js2-keyword-node :type js2-NULL)
-        (js2-report-error "msg.syntax")
-        (make-js2-error-node)))
-     (t
-      (let* ((js2-in-for-init nil)
-             (expr (js2-parse-expr))
-             (pn (make-js2-paren-node :pos px-pos
-                                      :expr expr)))
-        (js2-node-add-children pn (js2-paren-node-expr pn))
-        (js2-must-match js2-RP "msg.no.paren")
-        (setf (js2-node-len pn) (- (js2-current-token-end) px-pos))
-        pn)))))
-
-(defun js2-parse-expr (&optional oneshot)
-  (let* ((pn (js2-parse-assign-expr))
-         (pos (js2-node-pos pn))
-         left
-         right
-         op-pos)
-    (while (and (not oneshot)
-                (js2-match-token js2-COMMA))
-      (setq op-pos (- (js2-current-token-beg) pos))  ; relative
-      (setq right (js2-parse-assign-expr)
-            left pn
-            pn (make-js2-infix-node :type js2-COMMA
-                                    :pos pos
-                                    :len (- js2-ts-cursor pos)
-                                    :op-pos op-pos
-                                    :left left
-                                    :right right))
-      (js2-node-add-children pn left right))
-    pn))
-
-(defun js2-parse-assign-expr ()
-  (let ((tt (js2-get-token))
-        (pos (js2-current-token-beg))
-        pn left right op-pos
-        ts-state recorded-identifiers parsed-errors
-        async-p)
-    (if (= tt js2-YIELD)
-        (js2-parse-return-or-yield tt t)
-      ;; TODO(mooz): Bit confusing.
-      ;; If we meet `async` token and it's not part of `async
-      ;; function`, then this `async` is for a succeeding async arrow
-      ;; function.
-      ;; Since arrow function parsing doesn't rely on neither
-      ;; `js2-parse-function-stmt' nor `js2-parse-function-expr' that
-      ;; interpret `async` token, we trash `async` and just remember
-      ;; we met `async` keyword to `async-p'.
-      (when (js2-match-async-arrow-function)
-        (setq async-p t))
-      ;; Save the tokenizer state in case we find an arrow function
-      ;; and have to rewind.
-      (setq ts-state (make-js2-ts-state)
-            recorded-identifiers js2-recorded-identifiers
-            parsed-errors js2-parsed-errors)
-      ;; not yield - parse assignment expression
-      (setq pn (js2-parse-cond-expr)
-            tt (js2-get-token))
-      (cond
-       ((and (<= js2-first-assign tt)
-             (<= tt js2-last-assign))
-        ;; tt express assignment (=, |=, ^=, ..., %=)
-        (setq op-pos (- (js2-current-token-beg) pos)  ; relative
-              left pn)
-        ;; The assigned node could be a js2-prop-get-node (foo.bar = 0), we only
-        ;; care about assignment to strict variable names.
-        (when (js2-name-node-p left)
-          (js2-check-strict-identifier left))
-        (setq right (js2-parse-assign-expr)
-              pn (make-js2-assign-node :type tt
-                                       :pos pos
-                                       :len (- (js2-node-end right) pos)
-                                       :op-pos op-pos
-                                       :left left
-                                       :right right))
-        (when js2-parse-ide-mode
-          (js2-highlight-assign-targets pn left right)
-          (js2-record-imenu-functions right left))
-        ;; do this last so ide checks above can use absolute positions
-        (js2-node-add-children pn left right))
-       ((and (>= js2-language-version 200)
-             (or
-              (= tt js2-ARROW)
-              (and async-p
-                   (= (js2-peek-token) js2-ARROW))))
-        (js2-ts-seek ts-state)
-        (when async-p
-          (js2-record-face 'font-lock-keyword-face)
-          (js2-get-token))
-        (setq js2-recorded-identifiers recorded-identifiers
-              js2-parsed-errors parsed-errors)
-        (setq pn (js2-parse-function 'FUNCTION_ARROW (js2-current-token-beg) nil async-p)))
-       (t
-        (js2-unget-token)))
-      pn)))
-
-(defun js2-parse-cond-expr ()
-  (let ((pos (js2-current-token-beg))
-        (pn (js2-parse-or-expr))
-        test-expr
-        if-true
-        if-false
-        q-pos
-        c-pos)
-    (when (js2-match-token js2-HOOK)
-      (setq q-pos (- (js2-current-token-beg) pos)
-            if-true (let (js2-in-for-init) (js2-parse-assign-expr)))
-      (js2-must-match js2-COLON "msg.no.colon.cond")
-      (setq c-pos (- (js2-current-token-beg) pos)
-            if-false (js2-parse-assign-expr)
-            test-expr pn
-            pn (make-js2-cond-node :pos pos
-                                   :len (- (js2-node-end if-false) pos)
-                                   :test-expr test-expr
-                                   :true-expr if-true
-                                   :false-expr if-false
-                                   :q-pos q-pos
-                                   :c-pos c-pos))
-      (js2-node-add-children pn test-expr if-true if-false))
-    pn))
-
-(defun js2-make-binary (type left parser &optional no-get)
-  "Helper for constructing a binary-operator AST node.
-LEFT is the left-side-expression, already parsed, and the
-binary operator should have just been matched.
-PARSER is a function to call to parse the right operand,
-or a `js2-node' struct if it has already been parsed.
-FIXME: The latter option is unused?"
-  (let* ((pos (js2-node-pos left))
-         (op-pos (- (js2-current-token-beg) pos))
-         (right (if (js2-node-p parser)
-                    parser
-                  (unless no-get (js2-get-token))
-                  (funcall parser)))
-         (pn (make-js2-infix-node :type type
-                                  :pos pos
-                                  :len (- (js2-node-end right) pos)
-                                  :op-pos op-pos
-                                  :left left
-                                  :right right)))
-    (js2-node-add-children pn left right)
-    pn))
-
-(defun js2-parse-or-expr ()
-  (let ((pn (js2-parse-and-expr)))
-    (when (js2-match-token js2-OR)
-      (setq pn (js2-make-binary js2-OR
-                                pn
-                                'js2-parse-or-expr)))
-    pn))
-
-(defun js2-parse-and-expr ()
-  (let ((pn (js2-parse-bit-or-expr)))
-    (when (js2-match-token js2-AND)
-      (setq pn (js2-make-binary js2-AND
-                                pn
-                                'js2-parse-and-expr)))
-    pn))
-
-(defun js2-parse-bit-or-expr ()
-  (let ((pn (js2-parse-bit-xor-expr)))
-    (while (js2-match-token js2-BITOR)
-      (setq pn (js2-make-binary js2-BITOR
-                                pn
-                                'js2-parse-bit-xor-expr)))
-    pn))
-
-(defun js2-parse-bit-xor-expr ()
-  (let ((pn (js2-parse-bit-and-expr)))
-    (while (js2-match-token js2-BITXOR)
-      (setq pn (js2-make-binary js2-BITXOR
-                                pn
-                                'js2-parse-bit-and-expr)))
-    pn))
-
-(defun js2-parse-bit-and-expr ()
-  (let ((pn (js2-parse-eq-expr)))
-    (while (js2-match-token js2-BITAND)
-      (setq pn (js2-make-binary js2-BITAND
-                                pn
-                                'js2-parse-eq-expr)))
-    pn))
-
-(defconst js2-parse-eq-ops
-  (list js2-EQ js2-NE js2-SHEQ js2-SHNE))
-
-(defun js2-parse-eq-expr ()
-  (let ((pn (js2-parse-rel-expr))
-        tt)
-    (while (memq (setq tt (js2-get-token)) js2-parse-eq-ops)
-      (setq pn (js2-make-binary tt
-                                pn
-                                'js2-parse-rel-expr)))
-    (js2-unget-token)
-    pn))
-
-(defconst js2-parse-rel-ops
-  (list js2-IN js2-INSTANCEOF js2-LE js2-LT js2-GE js2-GT))
-
-(defun js2-parse-rel-expr ()
-  (let ((pn (js2-parse-shift-expr))
-        (continue t)
-        tt)
-    (while continue
-      (setq tt (js2-get-token))
-      (cond
-       ((and js2-in-for-init (= tt js2-IN))
-        (js2-unget-token)
-        (setq continue nil))
-       ((memq tt js2-parse-rel-ops)
-        (setq pn (js2-make-binary tt pn 'js2-parse-shift-expr)))
-       (t
-        (js2-unget-token)
-        (setq continue nil))))
-    pn))
-
-(defconst js2-parse-shift-ops
-  (list js2-LSH js2-URSH js2-RSH))
-
-(defun js2-parse-shift-expr ()
-  (let ((pn (js2-parse-add-expr))
-        tt
-        (continue t))
-    (while continue
-      (setq tt (js2-get-token))
-      (if (memq tt js2-parse-shift-ops)
-          (setq pn (js2-make-binary tt pn 'js2-parse-add-expr))
-        (js2-unget-token)
-        (setq continue nil)))
-    pn))
-
-(defun js2-parse-add-expr ()
-  (let ((pn (js2-parse-mul-expr))
-        tt
-        (continue t))
-    (while continue
-      (setq tt (js2-get-token))
-      (if (or (= tt js2-ADD) (= tt js2-SUB))
-          (setq pn (js2-make-binary tt pn 'js2-parse-mul-expr))
-        (js2-unget-token)
-        (setq continue nil)))
-    pn))
-
-(defconst js2-parse-mul-ops
-  (list js2-MUL js2-DIV js2-MOD))
-
-(defun js2-parse-mul-expr ()
-  (let ((pn (js2-parse-expon-expr))
-        tt
-        (continue t))
-    (while continue
-      (setq tt (js2-get-token))
-      (if (memq tt js2-parse-mul-ops)
-          (setq pn (js2-make-binary tt pn 'js2-parse-expon-expr))
-        (js2-unget-token)
-        (setq continue nil)))
-    pn))
-
-(defun js2-parse-expon-expr ()
-  (let ((pn (js2-parse-unary-expr)))
-    (when (>= js2-language-version 200)
-      (while (js2-match-token js2-EXPON)
-        (when (and (js2-unary-node-p pn)
-                   (not (memq (js2-node-type pn) '(js2-INC js2-DEC))))
-          (js2-report-error "msg.syntax" nil
-                            (js2-node-abs-pos pn) (js2-node-len pn)))
-        ;; Make it right-associative.
-        (setq pn (js2-make-binary js2-EXPON pn 'js2-parse-expon-expr))))
-    pn))
-
-(defun js2-make-unary (beg type parser &rest args)
-  "Make a unary node starting at BEG of type TYPE.
-If BEG is nil, `(js2-current-token-beg)' is used for the node
-start position.  PARSER is either a node (for postfix operators)
-or a function to call to parse the operand (for prefix
-operators)."
-  (let* ((pos (or beg (js2-current-token-beg)))
-         (postfix (js2-node-p parser))
-         (expr (if postfix
-                   parser
-                 (apply parser args)))
-         end
-         pn)
-    (if postfix  ; e.g. i++
-        (setq pos (js2-node-pos expr)
-              end (js2-current-token-end))
-      (setq end (js2-node-end expr)))
-    (setq pn (make-js2-unary-node :type type
-                                  :pos pos
-                                  :len (- end pos)
-                                  :operand expr))
-    (js2-node-add-children pn expr)
-    pn))
-
-(defconst js2-incrementable-node-types
-  (list js2-NAME js2-GETPROP js2-GETELEM js2-GET_REF js2-CALL)
-  "Node types that can be the operand of a ++ or -- operator.")
-
-(defun js2-check-bad-inc-dec (tt beg end unary)
-  (unless (memq (js2-node-type (js2-unary-node-operand unary))
-                js2-incrementable-node-types)
-    (js2-report-error (if (= tt js2-INC)
-                          "msg.bad.incr"
-                        "msg.bad.decr")
-                      nil beg (- end beg))))
-
-(defun js2-parse-unary-expr ()
-  (let ((tt (js2-current-token-type))
-        (beg (js2-current-token-beg)))
-    (cond
-     ((or (= tt js2-VOID)
-          (= tt js2-NOT)
-          (= tt js2-BITNOT)
-          (= tt js2-TYPEOF))
-      (js2-get-token)
-      (js2-make-unary beg tt 'js2-parse-unary-expr))
-     ((= tt js2-ADD)
-      (js2-get-token)
-      ;; Convert to special POS token in decompiler and parse tree
-      (js2-make-unary beg js2-POS 'js2-parse-unary-expr))
-     ((= tt js2-SUB)
-      (js2-get-token)
-      ;; Convert to special NEG token in decompiler and parse tree
-      (js2-make-unary beg js2-NEG 'js2-parse-unary-expr))
-     ((or (= tt js2-INC)
-          (= tt js2-DEC))
-      (js2-get-token)
-      (let ((beg2 (js2-current-token-beg))
-            (end (js2-current-token-end))
-            (expr (js2-make-unary beg tt 'js2-parse-member-expr t)))
-        (js2-check-bad-inc-dec tt beg2 end expr)
-        expr))
-     ((= tt js2-DELPROP)
-      (js2-get-token)
-      (js2-make-unary beg js2-DELPROP 'js2-parse-unary-expr))
-     ((js2-parse-await-maybe tt))
-     ((= tt js2-ERROR)
-      (js2-get-token)
-      (make-js2-error-node))  ; try to continue
-     ((and (= tt js2-LT)
-           js2-compiler-xml-available)
-      ;; XML stream encountered in expression.
-      (js2-parse-member-expr-tail t (js2-parse-xml-initializer)))
-     (t
-      (let ((pn (js2-parse-member-expr t))
-            ;; Don't look across a newline boundary for a postfix incop.
-            (tt (js2-peek-token-or-eol))
-            expr)
-        (when (or (= tt js2-INC) (= tt js2-DEC))
-          (js2-get-token)
-          (setf expr pn
-                pn (js2-make-unary (js2-node-pos expr) tt expr))
-          (js2-node-set-prop pn 'postfix t)
-          (js2-check-bad-inc-dec tt (js2-current-token-beg) (js2-current-token-end) pn))
-        pn)))))
-
-(defun js2-parse-xml-initializer ()
-  "Parse an E4X XML initializer.
-I'm parsing it the way Rhino parses it, but without the tree-rewriting.
-Then I'll postprocess the result, depending on whether we're in IDE
-mode or codegen mode, and generate the appropriate rewritten AST.
-IDE mode uses a rich AST that models the XML structure.  Codegen mode
-just concatenates everything and makes a new XML or XMLList out of it."
-  (let ((tt (js2-get-first-xml-token))
-        pn-xml pn expr kids expr-pos
-        (continue t)
-        (first-token t))
-    (when (not (or (= tt js2-XML) (= tt js2-XMLEND)))
-      (js2-report-error "msg.syntax"))
-    (setq pn-xml (make-js2-xml-node))
-    (while continue
-      (if first-token
-          (setq first-token nil)
-        (setq tt (js2-get-next-xml-token)))
-      (cond
-       ;; js2-XML means we found a {expr} in the XML stream.
-       ;; The token string is the XML up to the left-curly.
-       ((= tt js2-XML)
-        (push (make-js2-string-node :pos (js2-current-token-beg)
-                                    :len (- js2-ts-cursor (js2-current-token-beg)))
-              kids)
-        (js2-must-match js2-LC "msg.syntax")
-        (setq expr-pos js2-ts-cursor
-              expr (if (eq (js2-peek-token) js2-RC)
-                       (make-js2-empty-expr-node :pos expr-pos)
-                     (js2-parse-expr)))
-        (js2-must-match js2-RC "msg.syntax")
-        (setq pn (make-js2-xml-js-expr-node :pos (js2-node-pos expr)
-                                            :len (js2-node-len expr)
-                                            :expr expr))
-        (js2-node-add-children pn expr)
-        (push pn kids))
-       ;; a js2-XMLEND token means we hit the final close-tag.
-       ((= tt js2-XMLEND)
-        (push (make-js2-string-node :pos (js2-current-token-beg)
-                                    :len (- js2-ts-cursor (js2-current-token-beg)))
-              kids)
-        (dolist (kid (nreverse kids))
-          (js2-block-node-push pn-xml kid))
-        (setf (js2-node-len pn-xml) (- js2-ts-cursor
-                                       (js2-node-pos pn-xml))
-              continue nil))
-       (t
-        (js2-report-error "msg.syntax")
-        (setq continue nil))))
-    pn-xml))
-
-
-(defun js2-parse-argument-list ()
-  "Parse an argument list and return it as a Lisp list of nodes.
-Returns the list in reverse order.  Consumes the right-paren token."
-  (let (result)
-    (unless (js2-match-token js2-RP)
-      (cl-loop do
-               (let ((tt (js2-get-token))
-                     (beg (js2-current-token-beg)))
-                 (if (and (= tt js2-TRIPLEDOT)
-                          (>= js2-language-version 200))
-                     (push (js2-make-unary beg tt 'js2-parse-assign-expr) result)
-                   (js2-unget-token)
-                   (push (js2-parse-assign-expr) result)))
-               while
-               (and (js2-match-token js2-COMMA)
-                    (or (< js2-language-version 200)
-                        (not (= js2-RP (js2-peek-token))))))
-      (js2-must-match js2-RP "msg.no.paren.arg")
-      result)))
-
-(defun js2-parse-member-expr (&optional allow-call-syntax)
-  (let ((tt (js2-current-token-type))
-        pn pos target args beg end init)
-    (if (/= tt js2-NEW)
-        (setq pn (js2-parse-primary-expr))
-      ;; parse a 'new' expression
-      (js2-get-token)
-      (setq pos (js2-current-token-beg)
-            beg pos
-            target (js2-parse-member-expr)
-            end (js2-node-end target)
-            pn (make-js2-new-node :pos pos
-                                  :target target
-                                  :len (- end pos)))
-      (js2-highlight-function-call (js2-current-token))
-      (js2-node-add-children pn target)
-      (when (js2-match-token js2-LP)
-        ;; Add the arguments to pn, if any are supplied.
-        (setf beg pos  ; start of "new" keyword
-              pos (js2-current-token-beg)
-              args (nreverse (js2-parse-argument-list))
-              (js2-new-node-args pn) args
-              end (js2-current-token-end)
-              (js2-new-node-lp pn) (- pos beg)
-              (js2-new-node-rp pn) (- end 1 beg))
-        (apply #'js2-node-add-children pn args))
-      (when (and js2-allow-rhino-new-expr-initializer
-                 (js2-match-token js2-LC))
-        (setf init (js2-parse-object-literal)
-              end (js2-node-end init)
-              (js2-new-node-initializer pn) init)
-        (js2-node-add-children pn init))
-        (setf (js2-node-len pn) (- end beg)))  ; end outer if
-    (js2-parse-member-expr-tail allow-call-syntax pn)))
-
-(defun js2-parse-optional-chaining-operator (allow-call-syntax pn)
-  (let ((tt (js2-peek-token)))
-    (cond
-     ((eq tt js2-NAME)
-      (setq pn (js2-parse-property-access js2-DOT pn)))
-     ((eq tt js2-LB)
-      ;; skip left bracket token
-      (js2-get-token)
-      (setq pn (js2-parse-element-get pn)))
-     ((and (eq tt js2-LP) allow-call-syntax)
-      ;; unget optional chaining operator
-      ;; so current token is function name and could be highlighted
-      (js2-unget-token)
-      (setq pn (js2-parse-function-call pn t)))
-     (t
-      (js2-report-error "msg.bad.optional.chaining")))
-    pn))
-
-(defun js2-parse-member-expr-tail (allow-call-syntax pn)
-  "Parse a chain of property/array accesses or function calls.
-Includes parsing for E4X operators like `..' and `.@'.
-If ALLOW-CALL-SYNTAX is nil, stops when we encounter a left-paren.
-Returns an expression tree that includes PN, the parent node."
-  (let (tt
-        (continue t))
-    (while continue
-      (setq tt (js2-get-token))
-      (cond
-       ((or (= tt js2-DOT) (= tt js2-DOTDOT))
-        (setq pn (js2-parse-property-access tt pn)))
-       ((= tt js2-OPTIONAL-CHAINING)
-        (setq pn (js2-parse-optional-chaining-operator allow-call-syntax pn))
-        (unless pn (setq continue nil)))
-       ((= tt js2-DOTQUERY)
-        (setq pn (js2-parse-dot-query pn)))
-       ((= tt js2-LB)
-        (setq pn (js2-parse-element-get pn)))
-       ((= tt js2-LP)
-        (js2-unget-token)
-        (if allow-call-syntax
-            (setq pn (js2-parse-function-call pn))
-          (setq continue nil)))
-       ((= tt js2-TEMPLATE_HEAD)
-        (setq pn (js2-parse-tagged-template pn (js2-parse-template-literal))))
-       ((= tt js2-NO_SUBS_TEMPLATE)
-        (setq pn (js2-parse-tagged-template pn (make-js2-string-node :type tt))))
-       (t
-        (js2-unget-token)
-        (setq continue nil)))
-      (if (>= js2-highlight-level 2)
-          (js2-parse-highlight-member-expr-node pn)))
-    pn))
-
-(defun js2-parse-tagged-template (tag-node tpl-node)
-  "Parse tagged template expression."
-  (let* ((pos (js2-node-pos tag-node))
-         (pn (make-js2-tagged-template-node :pos pos
-                                            :len (- (js2-current-token-end) pos)
-                                            :tag tag-node
-                                            :template tpl-node)))
-    (js2-node-add-children pn tag-node tpl-node)
-    pn))
-
-(defun js2-parse-dot-query (pn)
-  "Parse a dot-query expression, e.g. foo.bar.(@name == 2)
-Last token parsed must be `js2-DOTQUERY'."
-  (let ((pos (js2-node-pos pn))
-        op-pos expr end)
-    (js2-must-have-xml)
-    (js2-set-requires-activation)
-    (setq op-pos (js2-current-token-beg)
-          expr (js2-parse-expr)
-          end (js2-node-end expr)
-          pn (make-js2-xml-dot-query-node :left pn
-                                          :pos pos
-                                          :op-pos op-pos
-                                          :right expr))
-    (js2-node-add-children pn
-                           (js2-xml-dot-query-node-left pn)
-                           (js2-xml-dot-query-node-right pn))
-    (if (js2-must-match js2-RP "msg.no.paren")
-        (setf (js2-xml-dot-query-node-rp pn) (js2-current-token-beg)
-              end (js2-current-token-end)))
-    (setf (js2-node-len pn) (- end pos))
-    pn))
-
-(defun js2-parse-element-get (pn)
-  "Parse an element-get expression, e.g. foo[bar].
-Last token parsed must be `js2-RB'."
-  (let ((lb (js2-current-token-beg))
-        (pos (js2-node-pos pn))
-        rb expr)
-    (setq expr (js2-parse-expr))
-    (if (js2-must-match js2-RB "msg.no.bracket.index")
-        (setq rb (js2-current-token-beg)))
-    (setq pn (make-js2-elem-get-node :target pn
-                                     :pos pos
-                                     :element expr
-                                     :lb (js2-relpos lb pos)
-                                     :rb (js2-relpos rb pos)
-                                     :len (- (js2-current-token-end) pos)))
-    (js2-node-add-children pn
-                           (js2-elem-get-node-target pn)
-                           (js2-elem-get-node-element pn))
-    pn))
-
-(defun js2-highlight-function-call (token)
-  (when (eq (js2-token-type token) js2-NAME)
-    (js2-record-face 'js2-function-call token)))
-
-(defun js2-parse-function-call (pn &optional use-optional-chaining-p)
-  (js2-highlight-function-call (js2-current-token))
-  (js2-get-token)
-  (let (args
-        (pos (js2-node-pos pn)))
-    (when use-optional-chaining-p
-      ;; skip optional chaining operator
-      (js2-get-token))
-    (setq pn (make-js2-call-node :pos pos
-                                 :target pn
-                                 :lp (- (js2-current-token-beg) pos)))
-    (js2-node-add-children pn (js2-call-node-target pn))
-    ;; Add the arguments to pn, if any are supplied.
-    (setf args (nreverse (js2-parse-argument-list))
-          (js2-call-node-rp pn) (- (js2-current-token-beg) pos)
-          (js2-call-node-args pn) args)
-    (apply #'js2-node-add-children pn args)
-    (setf (js2-node-len pn) (- js2-ts-cursor pos))
-    pn))
-
-(defun js2-parse-property-access (tt pn)
-  "Parse a property access, XML descendants access, or XML attr access."
-  (let ((member-type-flags 0)
-        (dot-pos (js2-current-token-beg))
-        (dot-len (if (= tt js2-DOTDOT) 2 1))
-        name
-        ref  ; right side of . or .. operator
-        result)
-    (when (= tt js2-DOTDOT)
-      (js2-must-have-xml)
-      (setq member-type-flags js2-descendants-flag))
-    (if (not js2-compiler-xml-available)
-        (progn
-          (js2-must-match-prop-name "msg.no.name.after.dot")
-          (setq name (js2-create-name-node t js2-GETPROP)
-                result (make-js2-prop-get-node :left pn
-                                               :pos (js2-current-token-beg)
-                                               :right name
-                                               :len (js2-current-token-len)))
-          (js2-node-add-children result pn name)
-          result)
-      ;; otherwise look for XML operators
-      (setf result (if (= tt js2-DOT)
-                       (make-js2-prop-get-node)
-                     (make-js2-infix-node :type js2-DOTDOT))
-            (js2-node-pos result) (js2-node-pos pn)
-            (js2-infix-node-op-pos result) dot-pos
-            (js2-infix-node-left result) pn  ; do this after setting position
-            tt (js2-get-prop-name-token))
-      (cond
-       ;; handles: name, ns::name, ns::*, ns::[expr]
-       ((= tt js2-NAME)
-        (setq ref (js2-parse-property-name -1 nil member-type-flags)))
-       ;; handles: *, *::name, *::*, *::[expr]
-       ((= tt js2-MUL)
-        (setq ref (js2-parse-property-name nil "*" member-type-flags)))
-       ;; handles: '@attr', '@ns::attr', '@ns::*', '@ns::[expr]', etc.
-       ((= tt js2-XMLATTR)
-        (setq result (js2-parse-attribute-access)))
-       (t
-        (js2-report-error "msg.no.name.after.dot" nil dot-pos dot-len)))
-      (if ref
-          (setf (js2-node-len result) (- (js2-node-end ref)
-                                         (js2-node-pos result))
-                (js2-infix-node-right result) ref))
-      (if (js2-infix-node-p result)
-          (js2-node-add-children result
-                                 (js2-infix-node-left result)
-                                 (js2-infix-node-right result)))
-      result)))
-
-(defun js2-parse-attribute-access ()
-  "Parse an E4X XML attribute expression.
-This includes expressions of the forms:
-
-  @attr      @ns::attr     @ns::*
-  @*         @*::attr      @*::*
-  @[expr]    @*::[expr]    @ns::[expr]
-
-Called if we peeked an '@' token."
-  (let ((tt (js2-get-prop-name-token))
-        (at-pos (js2-current-token-beg)))
-    (cond
-     ;; handles: @name, @ns::name, @ns::*, @ns::[expr]
-     ((= tt js2-NAME)
-      (js2-parse-property-name at-pos nil 0))
-     ;; handles: @*, @*::name, @*::*, @*::[expr]
-     ((= tt js2-MUL)
-      (js2-parse-property-name (js2-current-token-beg) "*" 0))
-     ;; handles @[expr]
-     ((= tt js2-LB)
-      (js2-parse-xml-elem-ref at-pos))
-     (t
-      (js2-report-error "msg.no.name.after.xmlAttr")
-      ;; Avoid cascaded errors that happen if we make an error node here.
-      (js2-parse-property-name (js2-current-token-beg) "" 0)))))
-
-(defun js2-parse-property-name (at-pos s member-type-flags)
-  "Check if :: follows name in which case it becomes qualified name.
-
-AT-POS is a natural number if we just read an '@' token, else nil.
-S is the name or string that was matched:  an identifier, 'throw' or '*'.
-MEMBER-TYPE-FLAGS is a bit set tracking whether we're a '.' or '..' child.
-
-Returns a `js2-xml-ref-node' if it's an attribute access, a child of a '..'
-operator, or the name is followed by ::.  For a plain name, returns a
-`js2-name-node'.  Returns a `js2-error-node' for malformed XML expressions."
-  (let ((pos (or at-pos (js2-current-token-beg)))
-        colon-pos
-        (name (js2-create-name-node t (js2-current-token-type) s))
-        ns tt pn)
-    (catch 'return
-      (when (js2-match-token js2-COLONCOLON)
-        (setq ns name
-              colon-pos (js2-current-token-beg)
-              tt (js2-get-prop-name-token))
-        (cond
-         ;; handles name::name
-         ((= tt js2-NAME)
-          (setq name (js2-create-name-node)))
-         ;; handles name::*
-         ((= tt js2-MUL)
-          (setq name (js2-create-name-node nil nil "*")))
-         ;; handles name::[expr]
-         ((= tt js2-LB)
-          (throw 'return (js2-parse-xml-elem-ref at-pos ns colon-pos)))
-         (t
-          (js2-report-error "msg.no.name.after.coloncolon"))))
-      (if (and (null ns) (zerop member-type-flags))
-          name
-        (prog1
-            (setq pn
-                  (make-js2-xml-prop-ref-node :pos pos
-                                              :len (- (js2-node-end name) pos)
-                                              :at-pos at-pos
-                                              :colon-pos colon-pos
-                                              :propname name))
-          (js2-node-add-children pn name))))))
-
-(defun js2-parse-xml-elem-ref (at-pos &optional namespace colon-pos)
-  "Parse the [expr] portion of an xml element reference.
-For instance, @[expr], @*::[expr], or ns::[expr]."
-  (let* ((lb (js2-current-token-beg))
-         (pos (or at-pos lb))
-         rb
-         (expr (js2-parse-expr))
-         (end (js2-node-end expr))
-         pn)
-    (if (js2-must-match js2-RB "msg.no.bracket.index")
-        (setq rb (js2-current-token-beg)
-              end (js2-current-token-end)))
-    (prog1
-        (setq pn
-              (make-js2-xml-elem-ref-node :pos pos
-                                          :len (- end pos)
-                                          :namespace namespace
-                                          :colon-pos colon-pos
-                                          :at-pos at-pos
-                                          :expr expr
-                                          :lb (js2-relpos lb pos)
-                                          :rb (js2-relpos rb pos)))
-      (js2-node-add-children pn namespace expr))))
-
-(defun js2-parse-destruct-primary-expr ()
-  (let ((js2-is-in-destructuring t))
-    (js2-parse-primary-expr)))
-
-(defun js2-parse-primary-expr ()
-  "Parse a literal (leaf) expression of some sort.
-Includes complex literals such as functions, object-literals,
-array-literals, array comprehensions and regular expressions."
-  (let (tt node)
-    (setq tt (js2-current-token-type))
-    (cond
-     ((= tt js2-CLASS)
-      (js2-parse-class-expr))
-     ((= tt js2-FUNCTION)
-      (js2-parse-function-expr))
-     ((js2-match-async-function)
-      (js2-parse-function-expr t))
-     ((= tt js2-LB)
-      (js2-parse-array-comp-or-literal))
-     ((= tt js2-LC)
-      (js2-parse-object-literal))
-     ((= tt js2-LET)
-      (js2-parse-let (js2-current-token-beg)))
-     ((= tt js2-LP)
-      (js2-parse-paren-expr-or-generator-comp))
-     ((= tt js2-XMLATTR)
-      (js2-must-have-xml)
-      (js2-parse-attribute-access))
-     ((= tt js2-NAME)
-      (js2-parse-name tt))
-     ((= tt js2-NUMBER)
-      (setq node (make-js2-number-node))
-      (when (and js2-in-use-strict-directive
-                 (= (js2-number-node-num-base node) 8)
-                 (js2-number-node-legacy-octal-p node))
-        (js2-report-error "msg.no.octal.strict"))
-      node)
-     ((or (= tt js2-STRING) (= tt js2-NO_SUBS_TEMPLATE))
-      (make-js2-string-node :type tt))
-     ((= tt js2-TEMPLATE_HEAD)
-      (js2-parse-template-literal))
-     ((or (= tt js2-DIV) (= tt js2-ASSIGN_DIV))
-      ;; Got / or /= which in this context means a regexp literal
-      (let* ((px-pos (js2-current-token-beg))
-             (flags (js2-read-regexp tt px-pos))
-             (end (js2-current-token-end)))
-        (prog1
-            (make-js2-regexp-node :pos px-pos
-                                  :len (- end px-pos)
-                                  :value (js2-current-token-string)
-                                  :flags flags)
-          (js2-set-face px-pos end 'font-lock-string-face 'record))))
-     ((or (= tt js2-NULL)
-          (= tt js2-THIS)
-          (= tt js2-SUPER)
-          (= tt js2-FALSE)
-          (= tt js2-TRUE))
-      (make-js2-keyword-node :type tt))
-     ((= tt js2-TRIPLEDOT)
-      ;; Likewise, only valid in an arrow function with a rest param.
-      (if (and (js2-match-token js2-NAME)
-               (js2-match-token js2-RP)
-               (eq (js2-peek-token) js2-ARROW))
-          (progn
-            (js2-unget-token)  ; Put back the right paren.
-            ;; See the previous case.
-            (make-js2-keyword-node :type js2-NULL))
-        (js2-report-error "msg.syntax")
-        (make-js2-error-node)))
-     ((= tt js2-RESERVED)
-      (js2-report-error "msg.reserved.id")
-      (make-js2-name-node))
-     ((= tt js2-ERROR)
-      ;; the scanner or one of its subroutines reported the error.
-      (make-js2-error-node))
-     ((= tt js2-EOF)
-      (let* ((px-pos (point-at-bol))
-             (len (- js2-ts-cursor px-pos)))
-        (js2-report-error "msg.unexpected.eof" nil px-pos len))
-      (make-js2-error-node :pos (1- js2-ts-cursor)))
-     (t
-      (js2-report-error "msg.syntax")
-      (make-js2-error-node)))))
-
-(defun js2-parse-template-literal ()
-  (let ((beg (js2-current-token-beg))
-        (kids (list (make-js2-string-node :type js2-TEMPLATE_HEAD)))
-        (tt js2-TEMPLATE_HEAD))
-    (while (eq tt js2-TEMPLATE_HEAD)
-      (push (js2-parse-expr) kids)
-      (js2-must-match js2-RC "msg.syntax")
-      (setq tt (js2-get-token 'TEMPLATE_TAIL))
-      (push (make-js2-string-node :type tt) kids))
-    (setq kids (nreverse kids))
-    (let ((tpl (make-js2-template-node :pos beg
-                                       :len (- (js2-current-token-end) beg)
-                                       :kids kids)))
-      (apply #'js2-node-add-children tpl kids)
-      tpl)))
-
-(defun js2-parse-name (_tt)
-  (let ((name (js2-current-token-string))
-        node)
-    (setq node (if js2-compiler-xml-available
-                   (js2-parse-property-name nil name 0)
-                 (js2-create-name-node 'check-activation nil name)))
-    (if (and js2-highlight-external-variables
-             ;; FIXME: What's TRT for `js2-xml-ref-node'?
-             (js2-name-node-p node))
-        (js2-record-name-node node))
-    node))
-
-(defun js2-parse-warn-trailing-comma (msg pos elems comma-pos)
-  (js2-add-strict-warning
-   msg nil
-   ;; back up from comma to beginning of line or array/objlit
-   (max (if elems
-            (js2-node-pos (car elems))
-          pos)
-        (save-excursion
-          (goto-char comma-pos)
-          (back-to-indentation)
-          (point)))
-   comma-pos))
-
-(defun js2-parse-array-comp-or-literal ()
-  (let ((pos (js2-current-token-beg)))
-    (if (and (>= js2-language-version 200)
-             (js2-match-token js2-FOR))
-        (js2-parse-array-comp pos)
-      (js2-parse-array-literal pos))))
-
-(defun js2-parse-array-literal (pos)
-  (let ((after-lb-or-comma t)
-        after-comma tt elems pn was-rest
-        (continue t))
-    (unless js2-is-in-destructuring
-      (js2-push-scope (make-js2-scope))) ; for the legacy array comp
-    (while continue
-      (setq tt (js2-get-token))
-      (cond
-       ;; end of array
-       ((or (= tt js2-RB)
-            (= tt js2-EOF))  ; prevent infinite loop
-        (if (= tt js2-EOF)
-            (js2-report-error "msg.no.bracket.arg" nil pos))
-        (when (and after-comma (< js2-language-version 170))
-          (js2-parse-warn-trailing-comma "msg.array.trailing.comma"
-                                         pos (remove nil elems) after-comma))
-        (setq continue nil
-              pn (make-js2-array-node :pos pos
-                                      :len (- js2-ts-cursor pos)
-                                      :elems (nreverse elems)))
-        (apply #'js2-node-add-children pn (js2-array-node-elems pn)))
-       ;; anything after rest element (...foo)
-       (was-rest
-        (js2-report-error "msg.param.after.rest"))
-       ;; comma
-       ((= tt js2-COMMA)
-        (setq after-comma (js2-current-token-end))
-        (if (not after-lb-or-comma)
-            (setq after-lb-or-comma t)
-          (push nil elems)))
-       ;; array comp
-       ((and (>= js2-language-version 170)
-             (not js2-is-in-destructuring)
-             (= tt js2-FOR)          ; check for array comprehension
-             (not after-lb-or-comma) ; "for" can't follow a comma
-             elems                   ; must have at least 1 element
-             (not (cdr elems)))      ; but no 2nd element
-        (js2-unget-token)
-        (setf continue nil
-              pn (js2-parse-legacy-array-comp (car elems) pos)))
-       ;; another element
-       (t
-        (unless after-lb-or-comma
-          (js2-report-error "msg.no.bracket.arg"))
-        (if (and (= tt js2-TRIPLEDOT)
-                 (>= js2-language-version 200))
-            ;; rest/spread operator
-            (progn
-              (push (js2-make-unary nil tt 'js2-parse-assign-expr)
-                    elems)
-              (if js2-is-in-destructuring
-                  (setq was-rest t)))
-          (js2-unget-token)
-          (push (js2-parse-assign-expr) elems))
-        (setq after-lb-or-comma nil
-              after-comma nil))))
-    (unless js2-is-in-destructuring
-      (js2-pop-scope))
-    pn))
-
-(defun js2-parse-legacy-array-comp (expr pos)
-  "Parse a legacy array comprehension (JavaScript 1.7).
-EXPR is the first expression after the opening left-bracket.
-POS is the beginning of the LB token preceding EXPR.
-We should have just parsed the 'for' keyword before calling this function."
-  (let ((current-scope js2-current-scope)
-        loops first filter result)
-    (unwind-protect
-        (progn
-          (while (js2-match-token js2-FOR)
-            (let ((loop (make-js2-comp-loop-node)))
-              (js2-push-scope loop)
-              (push loop loops)
-              (js2-parse-comp-loop loop)))
-          ;; First loop takes expr scope's parent.
-          (setf (js2-scope-parent-scope (setq first (car (last loops))))
-                (js2-scope-parent-scope current-scope))
-          ;; Set expr scope's parent to the last loop.
-          (setf (js2-scope-parent-scope current-scope) (car loops))
-          (if (/= (js2-get-token) js2-IF)
-              (js2-unget-token)
-            (setq filter (js2-parse-condition))))
-      (dotimes (_ (1- (length loops)))
-        (js2-pop-scope)))
-    (js2-must-match js2-RB "msg.no.bracket.arg" pos)
-    (setq result (make-js2-comp-node :pos pos
-                                     :len (- js2-ts-cursor pos)
-                                     :result expr
-                                     :loops (nreverse loops)
-                                     :filters (and filter (list (car filter)))
-                                     :form 'LEGACY_ARRAY))
-    ;; Set comp loop's parent to the last loop.
-    ;; TODO: Get rid of the bogus expr scope.
-    (setf (js2-scope-parent-scope result) first)
-    (apply #'js2-node-add-children result expr (car filter)
-           (js2-comp-node-loops result))
-    result))
-
-(defun js2-parse-array-comp (pos)
-  "Parse an ES6 array comprehension.
-POS is the beginning of the LB token.
-We should have just parsed the 'for' keyword before calling this function."
-  (let ((pn (js2-parse-comprehension pos 'ARRAY)))
-    (js2-must-match js2-RB "msg.no.bracket.arg" pos)
-    pn))
-
-(defun js2-parse-generator-comp (pos)
-  (let* ((js2-nesting-of-function (1+ js2-nesting-of-function))
-         (js2-current-script-or-fn
-          (make-js2-function-node :generator-type 'COMPREHENSION))
-         (pn (js2-parse-comprehension pos 'STAR_GENERATOR)))
-    (js2-must-match js2-RP "msg.no.paren" pos)
-    pn))
-
-(defun js2-parse-comprehension (pos form)
-  (let (loops filters expr result last)
-    (unwind-protect
-        (progn
-          (js2-unget-token)
-          (while (js2-match-token js2-FOR)
-            (let ((loop (make-js2-comp-loop-node)))
-              (js2-push-scope loop)
-              (push loop loops)
-              (js2-parse-comp-loop loop)))
-          (while (js2-match-token js2-IF)
-            (push (car (js2-parse-condition)) filters))
-          (setq expr (js2-parse-assign-expr))
-          (setq last (car loops)))
-      (dolist (_ loops)
-        (js2-pop-scope)))
-    (setq result (make-js2-comp-node :pos pos
-                                     :len (- js2-ts-cursor pos)
-                                     :result expr
-                                     :loops (nreverse loops)
-                                     :filters (nreverse filters)
-                                     :form form))
-    (apply #'js2-node-add-children result (js2-comp-node-loops result))
-    (apply #'js2-node-add-children result expr (js2-comp-node-filters result))
-    (setf (js2-scope-parent-scope result) last)
-    result))
-
-(defun js2-parse-comp-loop (pn &optional only-of-p)
-  "Parse a 'for [each] (foo [in|of] bar)' expression in an Array comprehension.
-The current token should be the initial FOR.
-If ONLY-OF-P is non-nil, only the 'for (foo of bar)' form is allowed."
-  (let ((pos (js2-comp-loop-node-pos pn))
-        tt iter obj foreach-p forof-p in-pos each-pos lp rp)
-    (when (and (not only-of-p) (js2-match-token js2-NAME))
-      (if (string= (js2-current-token-string) "each")
-          (progn
-            (setq foreach-p t
-                  each-pos (- (js2-current-token-beg) pos)) ; relative
-            (js2-record-face 'font-lock-keyword-face))
-        (js2-report-error "msg.no.paren.for")))
-    (if (js2-must-match js2-LP "msg.no.paren.for")
-        (setq lp (- (js2-current-token-beg) pos)))
-    (setq tt (js2-peek-token))
-    (cond
-     ((or (= tt js2-LB)
-          (= tt js2-LC))
-      (js2-get-token)
-      (setq iter (js2-parse-destruct-primary-expr))
-      (js2-define-destruct-symbols iter js2-LET
-                                   'font-lock-variable-name-face t))
-     ((js2-match-token js2-NAME)
-      (setq iter (js2-create-name-node)))
-     (t
-      (js2-report-error "msg.bad.var")))
-    ;; Define as a let since we want the scope of the variable to
-    ;; be restricted to the array comprehension
-    (if (js2-name-node-p iter)
-        (js2-define-symbol js2-LET (js2-name-node-name iter) pn t))
-    (if (or (and (not only-of-p) (js2-match-token js2-IN))
-            (and (>= js2-language-version 200)
-                 (js2-match-contextual-kwd "of")
-                 (setq forof-p t)))
-        (setq in-pos (- (js2-current-token-beg) pos))
-      (js2-report-error "msg.in.after.for.name"))
-    (setq obj (js2-parse-expr))
-    (if (js2-must-match js2-RP "msg.no.paren.for.ctrl")
-        (setq rp (- (js2-current-token-beg) pos)))
-    (setf (js2-node-pos pn) pos
-          (js2-node-len pn) (- js2-ts-cursor pos)
-          (js2-comp-loop-node-iterator pn) iter
-          (js2-comp-loop-node-object pn) obj
-          (js2-comp-loop-node-in-pos pn) in-pos
-          (js2-comp-loop-node-each-pos pn) each-pos
-          (js2-comp-loop-node-foreach-p pn) foreach-p
-          (js2-comp-loop-node-forof-p pn) forof-p
-          (js2-comp-loop-node-lp pn) lp
-          (js2-comp-loop-node-rp pn) rp)
-    (js2-node-add-children pn iter obj)
-    pn))
-
-(defun js2-parse-class-stmt ()
-  (let ((pos (js2-current-token-beg))
-        (_ (js2-must-match-name "msg.unnamed.class.stmt"))
-        (name (js2-create-name-node t)))
-    (js2-set-face (js2-node-pos name) (js2-node-end name)
-                  'font-lock-function-name-face 'record)
-    (let ((node (js2-parse-class pos 'CLASS_STATEMENT name)))
-      (js2-record-imenu-functions node name)
-      (js2-define-symbol js2-FUNCTION
-                         (js2-name-node-name name)
-                         node)
-      node)))
-
-(defun js2-parse-class-expr ()
-  (let ((pos (js2-current-token-beg))
-        name)
-    (when (js2-match-token js2-NAME)
-      (setq name (js2-create-name-node t)))
-    (js2-parse-class pos 'CLASS_EXPRESSION name)))
-
-(defun js2-parse-class (pos form name)
-  ;; class X [extends ...] {
-  (let (pn elems extends)
-    (if (js2-match-token js2-EXTENDS)
-        (if (= (js2-peek-token) js2-LC)
-            (js2-report-error "msg.missing.extends")
-          ;; TODO(sdh): this should be left-hand-side-expr, not assign-expr
-          (setq extends (js2-parse-assign-expr))
-          (if (not extends)
-              (js2-report-error "msg.bad.extends"))))
-    (js2-must-match js2-LC "msg.no.brace.class")
-    (setq elems (js2-parse-object-literal-elems t)
-          pn (make-js2-class-node :pos pos
-                                  :len (- js2-ts-cursor pos)
-                                  :form form
-                                  :name name
-                                  :extends extends
-                                  :elems elems))
-    (apply #'js2-node-add-children
-           pn name extends (js2-class-node-elems pn))
-    pn))
-
-(defun js2-parse-object-literal ()
-  (let* ((pos (js2-current-token-beg))
-         (elems (js2-parse-object-literal-elems))
-         (result (make-js2-object-node :pos pos
-                                       :len (- js2-ts-cursor pos)
-                                       :elems elems)))
-    (apply #'js2-node-add-children result (js2-object-node-elems result))
-    result))
-
-(defun js2-property-key-string (property-node)
-  "Return the key of PROPERTY-NODE (a `js2-object-prop-node' or
-`js2-method-node') as a string, or nil if it can't be
-represented as a string (e.g., the key is computed by an
-expression)."
-  (cond
-   ((js2-unary-node-p property-node) nil) ;; {...foo}
-   (t
-    (let ((key (js2-infix-node-left property-node)))
-      (when (js2-computed-prop-name-node-p key)
-        (setq key (js2-computed-prop-name-node-expr key)))
-      (cond
-       ((js2-name-node-p key)
-        (js2-name-node-name key))
-       ((js2-string-node-p key)
-        (js2-string-node-value key))
-       ((js2-number-node-p key)
-        (js2-number-node-value key)))))))
-
-(defun js2-parse-object-literal-elems (&optional class-p)
-  (let ((pos (js2-current-token-beg))
-        (static nil)
-        (continue t)
-        tt elems elem
-        elem-key-string previous-elem-key-string
-        after-comma previous-token)
-    (while continue
-      (setq tt (js2-get-prop-name-token)
-            static nil
-            elem nil
-            previous-token nil)
-      ;; Handle 'static' keyword only if we're in a class
-      (when (and class-p (= js2-NAME tt)
-                 (string= "static" (js2-current-token-string)))
-        (js2-record-face 'font-lock-keyword-face)
-        (setq static t
-              tt (js2-get-prop-name-token)))
-      ;; Handle generator * before the property name for in-line functions
-      (when (and (>= js2-language-version 200)
-                 (= js2-MUL tt))
-        (setq previous-token (js2-current-token)
-              tt (js2-get-prop-name-token)))
-      ;; Handle getter, setter and async methods
-      (let ((prop (js2-current-token-string)))
-        (when (and (>= js2-language-version 200)
-                   (= js2-NAME tt)
-                   (member prop '("get" "set" "async"))
-                   (member (js2-peek-token 'KEYWORD_IS_NAME)
-                           (list js2-NAME js2-STRING js2-NUMBER js2-LB)))
-          (setq previous-token (js2-current-token)
-                tt (js2-get-prop-name-token))))
-      (cond
-       ;; Rest/spread (...expr)
-       ((and (>= js2-language-version 200)
-             (not class-p) (not static) (not previous-token)
-             (= js2-TRIPLEDOT tt))
-        (setq after-comma nil
-              elem (js2-make-unary nil js2-TRIPLEDOT 'js2-parse-assign-expr)))
-       ;; Found a key/value property (of any sort)
-       ((member tt (list js2-NAME js2-STRING js2-NUMBER js2-LB))
-        (setq after-comma nil
-              elem (js2-parse-named-prop tt previous-token class-p))
-        (if (and (null elem)
-                 (not js2-recover-from-parse-errors))
-            (setq continue nil)))
-       ;; Break out of loop, and handle trailing commas.
-       ((or (= tt js2-RC)
-            (= tt js2-EOF))
-        (js2-unget-token)
-        (setq continue nil)
-        (if after-comma
-            (js2-parse-warn-trailing-comma "msg.extra.trailing.comma"
-                                           pos elems after-comma)))
-       ;; Skip semicolons in a class body
-       ((and class-p
-             (= tt js2-SEMI))
-        nil)
-       (t
-        (js2-report-error "msg.bad.prop")
-        (unless js2-recover-from-parse-errors
-          (setq continue nil))))         ; end switch
-      ;; Handle static for classes' codegen.
-      (if static
-          (if elem (js2-node-set-prop elem 'STATIC t)
-            (js2-report-error "msg.unexpected.static")))
-      ;; Handle commas, depending on class-p.
-      (let ((tok (js2-get-prop-name-token)))
-        (if (eq tok js2-COMMA)
-            (if class-p
-                (js2-report-error "msg.class.unexpected.comma")
-              (setq after-comma (js2-current-token-end)))
-          (js2-unget-token)
-          (unless class-p (setq continue nil))))
-      (when elem
-        (when (and js2-in-use-strict-directive
-                   (setq elem-key-string (js2-property-key-string elem))
-                   (cl-some
-                    (lambda (previous-elem)
-                      (and (setq previous-elem-key-string
-                                 (js2-property-key-string previous-elem))
-                           ;; Check if the property is a duplicate.
-                           (string= previous-elem-key-string elem-key-string)
-                           ;; But make an exception for getter / setter pairs.
-                           (not (and (js2-method-node-p elem)
-                                     (js2-method-node-p previous-elem)
-                                     (let ((type (js2-node-get-prop (js2-method-node-right elem) 'METHOD_TYPE))
-                                           (previous-type (js2-node-get-prop (js2-method-node-right previous-elem) 'METHOD_TYPE)))
-                                       (and (member type '(GET SET))
-                                            (member previous-type '(GET SET))
-                                            (not (eq type previous-type))))))))
-                    elems))
-          (js2-report-error "msg.dup.obj.lit.prop.strict"
-                            elem-key-string
-                            (js2-node-abs-pos (js2-infix-node-left elem))
-                            (js2-node-len (js2-infix-node-left elem))))
-        ;; Append any parsed element.
-        (push elem elems)))       ; end loop
-    (js2-must-match js2-RC "msg.no.brace.prop")
-    (nreverse elems)))
-
-(defun js2-parse-named-prop (tt previous-token &optional class-p)
-  "Parse a name, string, or getter/setter object property.
-When `js2-is-in-destructuring' is t, forms like {a, b, c} will be permitted."
-  (let ((key (js2-parse-prop-name tt))
-        (prop (and previous-token (js2-token-string previous-token)))
-        (property-type (when previous-token
-                             (if (= (js2-token-type previous-token) js2-MUL)
-                                 "*"
-                               (js2-token-string previous-token))))
-        pos)
-    (when (member prop '("get" "set" "async"))
-      (setq pos (js2-token-beg previous-token))
-      (js2-set-face (js2-token-beg previous-token)
-                    (js2-token-end previous-token)
-                    'font-lock-keyword-face 'record))  ; get/set/async
-    (cond
-     ;; method definition: {f() {...}}
-     ((and (= (js2-peek-token) js2-LP)
-           (>= js2-language-version 200))
-      (when (or (js2-name-node-p key) (js2-string-node-p key))
-        ;; highlight function name properties
-        (js2-record-face 'font-lock-function-name-face))
-      (js2-parse-method-prop pos key property-type))
-     ;; class field or binding element with initializer
-     ((and (= (js2-peek-token) js2-ASSIGN)
-           (>= js2-language-version 200))
-      (if (not (or class-p
-                   js2-is-in-destructuring))
-          (js2-report-error "msg.init.no.destruct"))
-      (js2-parse-initialized-binding key))
-     ;; regular prop
-     (t
-      (let ((beg (js2-current-token-beg))
-            (end (js2-current-token-end))
-            (expr (js2-parse-plain-property key class-p)))
-        (when (and (= tt js2-NAME)
-                   (not js2-is-in-destructuring)
-                   js2-highlight-external-variables
-                   (js2-node-get-prop expr 'SHORTHAND))
-          (js2-record-name-node key))
-        (js2-set-face beg end
-                      (if (js2-function-node-p
-                           (js2-object-prop-node-right expr))
-                          'font-lock-function-name-face
-                        'js2-object-property)
-                      'record)
-        expr)))))
-
-(defun js2-parse-initialized-binding (name)
-  "Parse a `SingleNameBinding' with initializer.
-
-`name' is the `BindingIdentifier'."
-  (when (js2-match-token js2-ASSIGN)
-    (js2-make-binary js2-ASSIGN name 'js2-parse-assign-expr t)))
-
-(defun js2-parse-prop-name (tt)
-  (cond
-   ;; Literal string keys: {'foo': 'bar'}
-   ((= tt js2-STRING)
-    (make-js2-string-node))
-   ;; Handle computed keys: {[Symbol.iterator]: ...}, *[1+2]() {...}},
-   ;; {[foo + bar]() { ... }}, {[get ['x' + 1]() {...}}
-   ((and (= tt js2-LB)
-         (>= js2-language-version 200))
-    (make-js2-computed-prop-name-node
-     :expr (prog1 (js2-parse-assign-expr)
-             (js2-must-match js2-RB "msg.missing.computed.rb"))))
-   ;; Numeric keys: {12: 'foo'}, {10.7: 'bar'}
-   ((= tt js2-NUMBER)
-    (make-js2-number-node))
-   ;; Unquoted names: {foo: 12}
-   ((= tt js2-NAME)
-    (js2-create-name-node))
-   ;; Anything else is an error
-   (t (js2-report-error "msg.bad.prop"))))
-
-(defun js2-parse-plain-property (prop &optional class-p)
-  "Parse a non-getter/setter property in an object literal.
-PROP is the node representing the property: a number, name,
-string or expression."
-  (let* (tt
-         (pos (js2-node-pos prop))
-         colon expr result)
-    (cond
-     ;; Abbreviated property, as in {foo, bar} or class {a; b}
-     ((and (>= js2-language-version 200)
-           (if class-p
-               (and (setq tt (js2-peek-token-or-eol))
-                    (member tt (list js2-EOL js2-RC js2-SEMI)))
-             (and (setq tt (js2-peek-token))
-                  (member tt (list js2-COMMA js2-RC))
-                  (js2-name-node-p prop))))
-      (setq result (make-js2-object-prop-node
-                    :pos pos
-                    :len (js2-node-len prop)
-                    :left prop
-                    :right prop
-                    :op-pos (- (js2-current-token-beg) pos)))
-      (js2-node-add-children result prop)
-      (js2-node-set-prop result 'SHORTHAND t)
-      result)
-     ;; Normal property
-     (t
-      (setq tt (js2-get-token))
-      (if (= tt js2-COLON)
-          (setq colon (- (js2-current-token-beg) pos)
-                expr (js2-parse-assign-expr))
-        (js2-report-error "msg.no.colon.prop")
-        (setq expr (make-js2-error-node)))
-      (setq result (make-js2-object-prop-node
-                   :pos pos
-                   ;; don't include last consumed token in length
-                   :len (- (+ (js2-node-pos expr)
-                              (js2-node-len expr))
-                           pos)
-                   :left prop
-                   :right expr
-                   :op-pos colon))
-      (js2-node-add-children result prop expr)
-      result))))
-
-(defun js2-parse-method-prop (pos prop type-string)
-  "Parse method property in an object literal or a class body.
-JavaScript syntax is:
-
-  { foo(...) {...}, get foo() {...}, set foo(x) {...}, *foo(...) {...},
-    async foo(...) {...} }
-
-and expression closure style is also supported
-
-  { get foo() x, set foo(x) _x = x }
-
-POS is the start position of the `get' or `set' keyword, if any.
-PROP is the `js2-name-node' representing the property name.
-TYPE-STRING is a string `get', `set', `*', or nil, indicating a found keyword."
-  (let* ((type (or (cdr (assoc type-string '(("get" . GET)
-                                             ("set" . SET)
-                                             ("async" . ASYNC))))
-                   'FUNCTION))
-         result end
-         (pos (or pos (js2-current-token-beg)))
-         (_ (js2-must-match js2-LP "msg.no.paren.parms"))
-         (fn (js2-parse-function 'FUNCTION_EXPRESSION pos
-                                 (string= type-string "*")
-                                 (eq type 'ASYNC)
-                                 nil)))
-    (js2-node-set-prop fn 'METHOD_TYPE type)  ; for codegen
-    (unless pos (setq pos (js2-node-pos prop)))
-    (setq end (js2-node-end fn)
-          result (make-js2-method-node :pos pos
-                                       :len (- end pos)
-                                       :left prop
-                                       :right fn))
-    (js2-node-add-children result prop fn)
-    result))
-
-(defun js2-create-name-node (&optional check-activation-p token string)
-  "Create a name node using the current token and, optionally, STRING.
-And, if CHECK-ACTIVATION-P is non-nil, use the value of TOKEN."
-  (let* ((beg (js2-current-token-beg))
-         (tt (js2-current-token-type))
-         (s (or string
-                (if (= js2-NAME tt)
-                    (js2-current-token-string)
-                  (js2-tt-name tt))))
-         name)
-    (setq name (make-js2-name-node :pos beg
-                                   :name s
-                                   :len (length s)))
-    (if check-activation-p
-        (js2-check-activation-name s (or token js2-NAME)))
-    name))
-
-;;; Use AST to extract semantic information
-
-(defun js2-get-element-index-from-array-node (elem array-node &optional hardcoded-array-index)
-  "Get index of ELEM from ARRAY-NODE or 0 and return it as string."
-  (let ((idx 0) elems (rlt hardcoded-array-index))
-    (setq elems (js2-array-node-elems array-node))
-    (if (and elem (not hardcoded-array-index))
-        (setq rlt (catch 'nth-elt
-                    (dolist (x elems)
-                      ;; We know the ELEM does belong to ARRAY-NODE,
-                      (if (eq elem x) (throw 'nth-elt idx))
-                      (setq idx (1+ idx)))
-                    0)))
-    (format "[%s]" rlt)))
-
-(defun js2-print-json-path (&optional hardcoded-array-index)
-  "Print the path to the JSON value under point, and save it in the kill ring.
-If HARDCODED-ARRAY-INDEX provided, array index in JSON path is replaced with it."
-  (interactive "P")
-  (js2-reparse)
-  (let (previous-node current-node
-        key-name
-        rlt)
-
-    ;; The `js2-node-at-point' starts scanning from AST root node.
-    ;; So there is no way to optimize it.
-    (setq current-node (js2-node-at-point))
-
-    (while (not (js2-ast-root-p current-node))
-      (cond
-       ;; JSON property node
-       ((js2-object-prop-node-p current-node)
-        (setq key-name (js2-prop-node-name (js2-object-prop-node-left current-node)))
-        (if rlt (setq rlt (concat "." key-name rlt))
-          (setq rlt (concat "." key-name))))
-
-       ;; Array node
-       ((or (js2-array-node-p current-node))
-        (setq rlt (concat (js2-get-element-index-from-array-node previous-node
-                                                                 current-node
-                                                                 hardcoded-array-index)
-                          rlt)))
-
-       ;; Other nodes are ignored
-       (t))
-
-      ;; current node is archived
-      (setq previous-node current-node)
-      ;; Get parent node and continue the loop
-      (setq current-node (js2-node-parent current-node)))
-
-    (cond
-     (rlt
-      ;; Clean the final result
-      (setq rlt (replace-regexp-in-string "^\\." "" rlt))
-      (kill-new rlt)
-      (message "%s => kill-ring" rlt))
-     (t
-      (message "No JSON path found!")))
-
-    rlt))
-
-;;; Indentation support (bouncing)
-
-;; In recent-enough Emacs, we reuse the indentation code from
-;; `js-mode'.  To continue support for the older versions, some code
-;; that was here previously was moved to `js2-old-indent.el'.
-
-;; Whichever indenter is used, it's often "wrong", however, and needs
-;; to be overridden.  The right long-term solution is probably to
-;; emulate (or integrate with) cc-engine, but it's a nontrivial amount
-;; of coding.  Even when a parse tree from `js2-parse' is present,
-;; which is not true at the moment the user is typing, computing
-;; indentation is still thousands of lines of code to handle every
-;; possible syntactic edge case.
-
-;; In the meantime, the compromise solution is that we offer a "bounce
-;; indenter", configured with `js2-bounce-indent-p', which cycles the
-;; current line indent among various likely guess points.  This approach
-;; is far from perfect, but should at least make it slightly easier to
-;; move the line towards its desired indentation when manually
-;; overriding Karl's heuristic nesting guesser.
-
-(defun js2-backward-sws ()
-  "Move backward through whitespace and comments."
-  (interactive)
-  (while (forward-comment -1)))
-
-(defun js2-forward-sws ()
-  "Move forward through whitespace and comments."
-  (interactive)
-  (while (forward-comment 1)))
-
-(defun js2-arglist-close ()
-  "Return non-nil if we're on a line beginning with a close-paren/brace."
-  (save-excursion
-    (goto-char (point-at-bol))
-    (js2-forward-sws)
-    (looking-at "[])}]")))
-
-(defun js2-indent-looks-like-label-p ()
-  (goto-char (point-at-bol))
-  (js2-forward-sws)
-  (looking-at (concat js2-mode-identifier-re ":")))
-
-(defun js2-indent-in-objlit-p (parse-status)
-  "Return non-nil if this looks like an object-literal entry."
-  (let ((start (nth 1 parse-status)))
-    (and
-     start
-     (save-excursion
-       (and (zerop (forward-line -1))
-            (not (< (point) start))     ; crossed a {} boundary
-            (js2-indent-looks-like-label-p)))
-     (save-excursion
-       (js2-indent-looks-like-label-p)))))
-
-;; If prev line looks like foobar({ then we're passing an object
-;; literal to a function call, and people pretty much always want to
-;; de-dent back to the previous line, so move the 'basic-offset'
-;; position to the front.
-(defun js2-indent-objlit-arg-p (parse-status)
-  (save-excursion
-    (back-to-indentation)
-    (js2-backward-sws)
-    (and (eq (1- (point)) (nth 1 parse-status))
-         (eq (char-before) ?{)
-         (progn
-           (forward-char -1)
-           (skip-chars-backward " \t")
-           (eq (char-before) ?\()))))
-
-(defun js2-indent-case-block-p ()
-  (save-excursion
-    (back-to-indentation)
-    (js2-backward-sws)
-    (goto-char (point-at-bol))
-    (skip-chars-forward " \t")
-    (looking-at "case\\s-.+:")))
-
-(defun js2-bounce-indent (normal-col parse-status &optional backward)
-  "Cycle among alternate computed indentation positions.
-PARSE-STATUS is the result of `parse-partial-sexp' from the beginning
-of the buffer to the current point.  NORMAL-COL is the indentation
-column computed by the heuristic guesser based on current paren,
-bracket, brace and statement nesting.  If BACKWARDS, cycle positions
-in reverse."
-  (let ((cur-indent (current-indentation))
-        (old-buffer-undo-list buffer-undo-list)
-        ;; Emacs 21 only has `count-lines', not `line-number-at-pos'
-        (current-line (save-excursion
-                        (forward-line 0)  ; move to bol
-                        (1+ (count-lines (point-min) (point)))))
-        positions pos main-pos anchor arglist-cont same-indent
-        basic-offset computed-pos)
-    ;; temporarily don't record undo info, if user requested this
-    (when js2-mode-indent-inhibit-undo
-      (setq buffer-undo-list t))
-    (unwind-protect
-        (progn
-          ;; First likely point:  indent from beginning of previous code line
-          (push (setq basic-offset
-                      (+ (save-excursion
-                           (back-to-indentation)
-                           (js2-backward-sws)
-                           (back-to-indentation)
-                           (current-column))
-                         js2-basic-offset))
-                positions)
-
-          ;; (First + epsilon) likely point:  indent 2x from beginning of
-          ;; previous code line.  Google does it this way.
-          (push (setq basic-offset
-                      (+ (save-excursion
-                           (back-to-indentation)
-                           (js2-backward-sws)
-                           (back-to-indentation)
-                           (current-column))
-                         (* 2 js2-basic-offset)))
-                positions)
-
-          ;; Second likely point:  indent from assign-expr RHS.  This
-          ;; is just a crude guess based on finding " = " on the previous
-          ;; line containing actual code.
-          (setq pos (save-excursion
-                      (forward-line -1)
-                      (goto-char (point-at-bol))
-                      (when (re-search-forward "\\s-+\\(=\\)\\s-+"
-                                               (point-at-eol) t)
-                        (goto-char (match-end 1))
-                        (skip-chars-forward " \t\r\n")
-                        (current-column))))
-          (when pos
-            (cl-incf pos js2-basic-offset)
-            (push pos positions))
-
-          ;; Third likely point:  same indent as previous line of code.
-          ;; Make it the first likely point if we're not on an
-          ;; arglist-close line and previous line ends in a comma, or
-          ;; both this line and prev line look like object-literal
-          ;; elements.
-          (setq pos (save-excursion
-                      (goto-char (point-at-bol))
-                      (js2-backward-sws)
-                      (back-to-indentation)
-                      (prog1
-                          (current-column)
-                        ;; while we're here, look for trailing comma
-                        (if (save-excursion
-                              (goto-char (point-at-eol))
-                              (js2-backward-sws)
-                              (eq (char-before) ?,))
-                            (setq arglist-cont (1- (point)))))))
-          (when pos
-            (if (and (or arglist-cont
-                         (js2-indent-in-objlit-p parse-status))
-                     (not (js2-arglist-close)))
-                (setq same-indent pos))
-            (push pos positions))
-
-          ;; Fourth likely point:  first preceding code with less indentation.
-          ;; than the immediately preceding code line.
-          (setq pos (save-excursion
-                      (back-to-indentation)
-                      (js2-backward-sws)
-                      (back-to-indentation)
-                      (setq anchor (current-column))
-                      (while (and (zerop (forward-line -1))
-                                  (>= (progn
-                                        (back-to-indentation)
-                                        (current-column))
-                                      anchor)))
-                      (setq pos (current-column))))
-          (push pos positions)
-
-          ;; nesting-heuristic position, main by default
-          (push (setq main-pos normal-col) positions)
-
-          ;; delete duplicates and sort positions list
-          (setq positions (sort (delete-dups positions) '<))
-
-          ;; comma-list continuation lines:  prev line indent takes precedence
-          (if same-indent
-              (setq main-pos same-indent))
-
-          ;; common special cases where we want to indent in from previous line
-          (if (or (js2-indent-case-block-p)
-                  (js2-indent-objlit-arg-p parse-status))
-              (setq main-pos basic-offset))
-
-          ;; if bouncing backward, reverse positions list
-          (if backward
-              (setq positions (reverse positions)))
-
-          ;; record whether we're already sitting on one of the alternatives
-          (setq pos (member cur-indent positions))
-
-          (cond
-           ;; case 0:  we're one one of the alternatives and this is the
-           ;; first time they've pressed TAB on this line (best-guess).
-           ((and js2-mode-indent-ignore-first-tab
-                 pos
-                 ;; first time pressing TAB on this line?
-                 (not (eq js2-mode-last-indented-line current-line)))
-            ;; do nothing
-            (setq computed-pos nil))
-           ;; case 1:  only one computed position => use it
-           ((null (cdr positions))
-            (setq computed-pos 0))
-           ;; case 2:  not on any of the computed spots => use main spot
-           ((not pos)
-            (setq computed-pos (js2-position main-pos positions)))
-           ;; case 3:  on last position:  cycle to first position
-           ((null (cdr pos))
-            (setq computed-pos 0))
-           ;; case 4:  on intermediate position:  cycle to next position
-           (t
-            (setq computed-pos (js2-position (cl-second pos) positions))))
-
-          ;; see if any hooks want to indent; otherwise we do it
-          (cl-loop with result = nil
-                   for hook in js2-indent-hook
-                   while (null result)
-                   do
-                   (setq result (funcall hook positions computed-pos))
-                   finally do
-                   (unless (or result (null computed-pos))
-                     (indent-line-to (nth computed-pos positions)))))
-
-      ;; finally
-      (if js2-mode-indent-inhibit-undo
-          (setq buffer-undo-list old-buffer-undo-list))
-      ;; see commentary for `js2-mode-last-indented-line'
-      (setq js2-mode-last-indented-line current-line))))
-
-(defun js2-1-line-comment-continuation-p ()
-  "Return t if we're in a 1-line comment continuation.
-If so, we don't ever want to use bounce-indent."
-  (save-excursion
-    (and (progn
-           (forward-line 0)
-           (looking-at "\\s-*//"))
-         (progn
-           (forward-line -1)
-           (forward-line 0)
-           (when (looking-at "\\s-*$")
-             (js2-backward-sws)
-             (forward-line 0))
-           (looking-at "\\s-*//")))))
-
-(defun js2-indent-bounce (&optional backward)
-  "Indent the current line, bouncing between several positions."
-  (interactive)
-  (let (parse-status offset indent-col
-        ;; Don't whine about errors/warnings when we're indenting.
-        ;; This has to be set before calling parse-partial-sexp below.
-        (inhibit-point-motion-hooks t))
-    (setq parse-status (save-excursion
-                         (syntax-ppss (point-at-bol)))
-          offset (- (point) (save-excursion
-                              (back-to-indentation)
-                              (point))))
-    ;; Don't touch multiline strings.
-    (unless (nth 3 parse-status)
-      (setq indent-col (js2-proper-indentation parse-status))
-      (cond
-       ;; It doesn't work well on first line of buffer.
-       ((and (not (nth 4 parse-status))
-             (not (js2-same-line (point-min)))
-             (not (js2-1-line-comment-continuation-p)))
-        (js2-bounce-indent indent-col parse-status backward))
-       ;; just indent to the guesser's likely spot
-       (t (indent-line-to indent-col)))
-      (when (cl-plusp offset)
-        (forward-char offset)))))
-
-(defun js2-indent-bounce-backward ()
-  "Indent the current line, bouncing between positions in reverse."
-  (interactive)
-  (js2-indent-bounce t))
-
-(defun js2-indent-region (start end)
-  "Indent the region, but don't use bounce indenting."
-  (let ((js2-bounce-indent-p nil)
-        (indent-region-function nil)
-        (after-change-functions (remq 'js2-mode-edit
-                                      after-change-functions)))
-    (indent-region start end nil) ; nil for byte-compiler
-    (js2-mode-edit start end (- end start))))
-
-(defvar js2-minor-mode-map
-  (let ((map (make-sparse-keymap)))
-    (define-key map (kbd "C-c C-`") #'js2-next-error)
-    map)
-  "Keymap used when `js2-minor-mode' is active.")
-
-;;;###autoload
-(define-minor-mode js2-minor-mode
-  "Minor mode for running js2 as a background linter.
-This allows you to use a different major mode for JavaScript editing,
-such as `js-mode', while retaining the asynchronous error/warning
-highlighting features of `js2-mode'."
-  :group 'js2-mode
-  :lighter " js-lint"
-  (if (derived-mode-p 'js2-mode)
-      (setq js2-minor-mode nil)
-    (if js2-minor-mode
-        (js2-minor-mode-enter)
-      (js2-minor-mode-exit))))
-
-(defun js2-minor-mode-enter ()
-  "Initialization for `js2-minor-mode'."
-  (set (make-local-variable 'max-lisp-eval-depth)
-       (max max-lisp-eval-depth 3000))
-  (setq next-error-function #'js2-next-error)
-  ;; Experiment:  make reparse-delay longer for longer files.
-  (if (cl-plusp js2-dynamic-idle-timer-adjust)
-      (setq js2-idle-timer-delay
-            (* js2-idle-timer-delay
-               (/ (point-max) js2-dynamic-idle-timer-adjust))))
-  (setq js2-mode-buffer-dirty-p t
-        js2-mode-parsing nil)
-  (set (make-local-variable 'js2-highlight-level) 0) ; no syntax highlighting
-  (set (make-local-variable 'js2-mode-change-syntax-p) nil)
-  (add-hook 'after-change-functions #'js2-minor-mode-edit nil t)
-  (add-hook 'change-major-mode-hook #'js2-minor-mode-exit nil t)
-  (when js2-include-jslint-globals
-    (add-hook 'js2-post-parse-callbacks 'js2-apply-jslint-globals nil t))
-  (when js2-include-jslint-declaration-externs
-    (add-hook 'js2-post-parse-callbacks 'js2-apply-jslint-declaration-externs nil t))
-  (run-hooks 'js2-init-hook)
-  (js2-reparse))
-
-(defun js2-minor-mode-exit ()
-  "Turn off `js2-minor-mode'."
-  (setq next-error-function nil)
-  (remove-hook 'after-change-functions #'js2-mode-edit t)
-  (remove-hook 'change-major-mode-hook #'js2-minor-mode-exit t)
-  (when js2-mode-node-overlay
-    (delete-overlay js2-mode-node-overlay)
-    (setq js2-mode-node-overlay nil))
-  (js2-remove-overlays)
-  (remove-hook 'js2-post-parse-callbacks 'js2-apply-jslint-globals t)
-  (remove-hook 'js2-post-parse-callbacks 'js2-apply-jslint-declaration-externs t)
-  (setq js2-mode-ast nil))
-
-(defvar js2-source-buffer nil "Linked source buffer for diagnostics view")
-(make-variable-buffer-local 'js2-source-buffer)
-
-(cl-defun js2-display-error-list ()
-  "Display a navigable buffer listing parse errors/warnings."
-  (interactive)
-  (unless (js2-have-errors-p)
-    (message "No errors")
-    (cl-return-from js2-display-error-list))
-  (cl-labels ((annotate-list
-               (lst type)
-               "Add diagnostic TYPE and line number to errs list"
-               (mapcar (lambda (err)
-                         (list err type (line-number-at-pos (nth 1 err))))
-                       lst)))
-    (let* ((srcbuf (current-buffer))
-           (errbuf (get-buffer-create "*js-lint*"))
-           (errors (annotate-list
-                    (when js2-mode-ast (js2-ast-root-errors js2-mode-ast))
-                    'js2-error))  ; must be a valid face name
-           (warnings (annotate-list
-                      (when js2-mode-ast (js2-ast-root-warnings js2-mode-ast))
-                      'js2-warning))  ; must be a valid face name
-           (all-errs (sort (append errors warnings)
-                           (lambda (e1 e2) (< (cl-cadar e1) (cl-cadar e2))))))
-      (with-current-buffer errbuf
-        (let ((inhibit-read-only t))
-          (erase-buffer)
-          (dolist (err all-errs)
-            (cl-destructuring-bind ((msg-key beg _end &rest) type line) err
-              (insert-text-button
-               (format "line %d: %s" line (js2-get-msg msg-key))
-               'face type
-               'follow-link "\C-m"
-               'action 'js2-error-buffer-jump
-               'js2-msg (js2-get-msg msg-key)
-               'js2-pos beg)
-              (insert "\n"))))
-        (js2-error-buffer-mode)
-        (setq js2-source-buffer srcbuf)
-        (pop-to-buffer errbuf)
-        (goto-char (point-min))
-        (unless (eobp)
-          (js2-error-buffer-view))))))
-
-(defvar js2-error-buffer-mode-map
-  (let ((map (make-sparse-keymap)))
-    (define-key map "n" #'js2-error-buffer-next)
-    (define-key map "p" #'js2-error-buffer-prev)
-    (define-key map (kbd "RET") #'js2-error-buffer-jump)
-    (define-key map "o" #'js2-error-buffer-view)
-    (define-key map "q" #'js2-error-buffer-quit)
-    map)
-  "Keymap used for js2 diagnostics buffers.")
-
-(defun js2-error-buffer-mode ()
-  "Major mode for js2 diagnostics buffers.
-Selecting an error will jump it to the corresponding source-buffer error.
-\\{js2-error-buffer-mode-map}"
-  (interactive)
-  (setq major-mode 'js2-error-buffer-mode
-        mode-name "JS Lint Diagnostics")
-  (use-local-map js2-error-buffer-mode-map)
-  (setq truncate-lines t)
-  (set-buffer-modified-p nil)
-  (setq buffer-read-only t)
-  (run-hooks 'js2-error-buffer-mode-hook))
-
-(defun js2-error-buffer-next ()
-  "Move to next error and view it."
-  (interactive)
-  (when (zerop (forward-line 1))
-    (js2-error-buffer-view)))
-
-(defun js2-error-buffer-prev ()
-  "Move to previous error and view it."
-  (interactive)
-  (when (zerop (forward-line -1))
-    (js2-error-buffer-view)))
-
-(defun js2-error-buffer-quit ()
-  "Kill the current buffer."
-  (interactive)
-  (kill-buffer))
-
-(defun js2-error-buffer-jump (&rest ignored)
-  "Jump cursor to current error in source buffer."
-  (interactive)
-  (when (js2-error-buffer-view)
-    (pop-to-buffer js2-source-buffer)))
-
-(defun js2-error-buffer-view ()
-  "Scroll source buffer to show error at current line."
-  (interactive)
-  (cond
-   ((not (eq major-mode 'js2-error-buffer-mode))
-    (message "Not in a js2 errors buffer"))
-   ((not (buffer-live-p js2-source-buffer))
-    (message "Source buffer has been killed"))
-   ((not (wholenump (get-text-property (point) 'js2-pos)))
-    (message "There does not seem to be an error here"))
-   (t
-    (let ((pos (get-text-property (point) 'js2-pos))
-          (msg (get-text-property (point) 'js2-msg)))
-      (save-selected-window
-        (pop-to-buffer js2-source-buffer)
-        (goto-char pos)
-        (message msg))))))
-
-;;;###autoload
-(define-derived-mode js2-mode js-mode "Javascript-IDE"
-  "Major mode for editing JavaScript code."
-  (set (make-local-variable 'max-lisp-eval-depth)
-       (max max-lisp-eval-depth 3000))
-  (set (make-local-variable 'indent-line-function) #'js2-indent-line)
-  (set (make-local-variable 'indent-region-function) #'js2-indent-region)
-  (set (make-local-variable 'syntax-propertize-function) nil)
-  (set (make-local-variable 'comment-line-break-function) #'js2-line-break)
-  (set (make-local-variable 'beginning-of-defun-function) #'js2-beginning-of-defun)
-  (set (make-local-variable 'end-of-defun-function) #'js2-end-of-defun)
-  ;; We un-confuse `parse-partial-sexp' by setting syntax-table properties
-  ;; for characters inside regexp literals.
-  (set (make-local-variable 'parse-sexp-lookup-properties) t)
-  ;; this is necessary to make `show-paren-function' work properly
-  (set (make-local-variable 'parse-sexp-ignore-comments) t)
-  ;; needed for M-x rgrep, among other things
-  (put 'js2-mode 'find-tag-default-function #'js2-mode-find-tag)
-
-  (setq font-lock-defaults '(nil t))
-
-  ;; Experiment:  make reparse-delay longer for longer files.
-  (when (cl-plusp js2-dynamic-idle-timer-adjust)
-    (setq js2-idle-timer-delay
-          (* js2-idle-timer-delay
-             (/ (point-max) js2-dynamic-idle-timer-adjust))))
-
-  (add-hook 'change-major-mode-hook #'js2-mode-exit nil t)
-  (add-hook 'after-change-functions #'js2-mode-edit nil t)
-  (setq imenu-create-index-function #'js2-mode-create-imenu-index)
-  (setq next-error-function #'js2-next-error)
-  (imenu-add-to-menubar (concat "IM-" mode-name))
-  (add-to-invisibility-spec '(js2-outline . t))
-  (set (make-local-variable 'line-move-ignore-invisible) t)
-  (set (make-local-variable 'forward-sexp-function) #'js2-mode-forward-sexp)
-  (when (fboundp 'cursor-sensor-mode) (cursor-sensor-mode 1))
-
-  (setq js2-mode-functions-hidden nil
-        js2-mode-comments-hidden nil
-        js2-mode-buffer-dirty-p t
-        js2-mode-parsing nil)
-
-  (when js2-include-jslint-globals
-    (add-hook 'js2-post-parse-callbacks 'js2-apply-jslint-globals nil t))
-  (when js2-include-jslint-declaration-externs
-    (add-hook 'js2-post-parse-callbacks 'js2-apply-jslint-declaration-externs nil t))
-
-  (run-hooks 'js2-init-hook)
-
-  (let ((js2-idle-timer-delay 0))
-    ;; Schedule parsing for after when the mode hooks run.
-    (js2-mode-reset-timer)))
-
-;;;###autoload
-(define-derived-mode js2-jsx-mode js2-mode "JSX-IDE"
-  "Major mode for editing JSX code in Emacs 26 and earlier.
-
-To edit JSX code in Emacs 27, use `js-mode' as your major mode
-with `js2-minor-mode' enabled.
-
-To customize the indentation for this mode, set the SGML offset
-variables (`sgml-basic-offset' et al) locally, like so:
-
-  (defun set-jsx-indentation ()
-    (setq-local sgml-basic-offset js2-basic-offset))
-  (add-hook \\='js2-jsx-mode-hook #\\='set-jsx-indentation)"
-  (unless (version< emacs-version "27.0")
-    ;; Emacs 27 causes a regression in this mode since JSX indentation
-    ;; begins to rely on js-mode’s `syntax-propertize-function', which
-    ;; JS2 is not currently using.
-    ;; https://github.com/mooz/js2-mode/issues/529 should address
-    ;; this.  https://github.com/mooz/js2-mode/issues/530 also has a
-    ;; piece related to the design of `js2-jsx-mode'.  Until these
-    ;; issues are addressed, ward Emacs 27 users away from this mode.
-    (display-warning 'js2-mode "For JSX support, use js-mode with js2-minor-mode"))
-  (set (make-local-variable 'indent-line-function) #'js2-jsx-indent-line))
-
-(defun js2-mode-exit ()
-  "Exit `js2-mode' and clean up."
-  (interactive)
-  (when js2-mode-node-overlay
-    (delete-overlay js2-mode-node-overlay)
-    (setq js2-mode-node-overlay nil))
-  (js2-remove-overlays)
-  (setq js2-mode-ast nil)
-  (remove-hook 'change-major-mode-hook #'js2-mode-exit t)
-  (remove-from-invisibility-spec '(js2-outline . t))
-  (js2-mode-show-all)
-  (with-silent-modifications
-    (js2-clear-face (point-min) (point-max))))
-
-(defun js2-mode-reset-timer ()
-  "Cancel any existing parse timer and schedule a new one."
-  (if js2-mode-parse-timer
-      (cancel-timer js2-mode-parse-timer))
-  (setq js2-mode-parsing nil)
-  (let ((timer (timer-create)))
-    (setq js2-mode-parse-timer timer)
-    (timer-set-function timer 'js2-mode-idle-reparse (list (current-buffer)))
-    (timer-set-idle-time timer js2-idle-timer-delay)
-    ;; http://debbugs.gnu.org/cgi/bugreport.cgi?bug=12326
-    (timer-activate-when-idle timer nil)))
-
-(defun js2-mode-idle-reparse (buffer)
-  "Run `js2-reparse' if BUFFER is the current buffer, or schedule
-it to be reparsed when the buffer is selected."
-  (cond ((eq buffer (current-buffer))
-         (js2-reparse))
-        ((buffer-live-p buffer)
-         ;; reparse when the buffer is selected again
-         (with-current-buffer buffer
-           (add-hook 'window-configuration-change-hook
-                     #'js2-mode-idle-reparse-inner
-                     nil t)))))
-
-(defun js2-mode-idle-reparse-inner ()
-  (remove-hook 'window-configuration-change-hook
-               #'js2-mode-idle-reparse-inner
-               t)
-  (js2-reparse))
-
-(defun js2-mode-edit (_beg _end _len)
-  "Schedule a new parse after buffer is edited.
-Buffer edit spans from BEG to END and is of length LEN."
-  (setq js2-mode-buffer-dirty-p t)
-  (js2-mode-hide-overlay)
-  (js2-mode-reset-timer))
-
-(defun js2-minor-mode-edit (_beg _end _len)
-  "Callback for buffer edits in `js2-mode'.
-Schedules a new parse after buffer is edited.
-Buffer edit spans from BEG to END and is of length LEN."
-  (setq js2-mode-buffer-dirty-p t)
-  (js2-mode-hide-overlay)
-  (js2-mode-reset-timer))
-
-(defun js2-reparse (&optional force)
-  "Re-parse current buffer after user finishes some data entry.
-If we get any user input while parsing, including cursor motion,
-we discard the parse and reschedule it.  If FORCE is nil, then the
-buffer will only rebuild its `js2-mode-ast' if the buffer is dirty."
-  (let (time
-        interrupted-p
-        (js2-compiler-strict-mode js2-mode-show-strict-warnings))
-    (unless js2-mode-parsing
-      (setq js2-mode-parsing t)
-      (unwind-protect
-          (when (or js2-mode-buffer-dirty-p force)
-            (js2-remove-overlays)
-            (setq js2-mode-buffer-dirty-p nil
-                  js2-mode-fontifications nil
-                  js2-mode-deferred-properties nil)
-            (if js2-mode-verbose-parse-p
-                (message "parsing..."))
-            (setq time
-                  (js2-time
-                   (setq interrupted-p
-                         (catch 'interrupted
-                           (js2-parse)
-                           (with-silent-modifications
-                             ;; if parsing is interrupted, comments and regex
-                             ;; literals stay ignored by `parse-partial-sexp'
-                             (when js2-mode-change-syntax-p
-                               (remove-text-properties (point-min) (point-max)
-                                                       '(syntax-table)))
-                             (js2-mode-apply-deferred-properties)
-                             (js2-mode-remove-suppressed-warnings)
-                             (js2-mode-show-warnings)
-                             (js2-mode-show-errors)
-                             (if (>= js2-highlight-level 1)
-                                 (js2-highlight-jsdoc js2-mode-ast)))
-                           nil))))
-            (if interrupted-p
-                (progn
-                  ;; unfinished parse => try again
-                  (setq js2-mode-buffer-dirty-p t)
-                  (js2-mode-reset-timer))
-              (if js2-mode-verbose-parse-p
-                  (message "Parse time: %s" time))))
-        (setq js2-mode-parsing nil)
-        (unless interrupted-p
-          (setq js2-mode-parse-timer nil))))))
-
-;; We bound it to [mouse-1] previously.  But the signature of
-;; mouse-set-point changed around 24.4, so it's kind of hard to keep
-;; it working in 24.1-24.3.  Since the command is not hugely
-;; important, we removed the binding (#356).  Maybe we'll bring it
-;; back when supporting <24.4 is not a goal anymore.
-(defun js2-mode-show-node (event &optional promote-to-region)
-  "Debugging aid:  highlight selected AST node on mouse click."
-  (interactive "e\np")
-  (mouse-set-point event promote-to-region)
-  (when js2-mode-show-overlay
-    (let ((node (js2-node-at-point))
-          beg end)
-      (if (null node)
-          (message "No node found at location %s" (point))
-        (setq beg (js2-node-abs-pos node)
-              end (+ beg (js2-node-len node)))
-        (if js2-mode-node-overlay
-            (move-overlay js2-mode-node-overlay beg end)
-          (setq js2-mode-node-overlay (make-overlay beg end))
-          (overlay-put js2-mode-node-overlay 'font-lock-face 'highlight))
-        (with-silent-modifications
-          (if (fboundp 'cursor-sensor-mode)
-              (put-text-property beg end 'cursor-sensor-functions
-                                 '(js2-mode-hide-overlay))
-            (put-text-property beg end 'point-left #'js2-mode-hide-overlay)))
-        (message "%s, parent: %s"
-                 (js2-node-short-name node)
-                 (if (js2-node-parent node)
-                     (js2-node-short-name (js2-node-parent node))
-                   "nil"))))))
-
-(defun js2-mode-hide-overlay (&optional arg1 arg2 _arg3)
-  "Remove the debugging overlay when point moves.
-ARG1, ARG2 and ARG3 have different values depending on whether this function
-was found on `point-left' or in `cursor-sensor-functions'."
-  (when js2-mode-node-overlay
-    (let ((beg (overlay-start js2-mode-node-overlay))
-          (end (overlay-end js2-mode-node-overlay))
-          (p2 (if (windowp arg1)
-                  ;; Called from cursor-sensor-functions.
-                  (window-point arg1)
-                ;; Called from point-left.
-                arg2)))
-      ;; Sometimes we're called spuriously.
-      (unless (and p2
-                   (>= p2 beg)
-                   (<= p2 end))
-        (with-silent-modifications
-          (remove-text-properties beg end
-                                  '(point-left nil cursor-sensor-functions)))
-        (delete-overlay js2-mode-node-overlay)
-        (setq js2-mode-node-overlay nil)))))
-
-(defun js2-mode-reset ()
-  "Debugging helper:  reset everything."
-  (interactive)
-  (js2-mode-exit)
-  (js2-mode))
-
-(defun js2-mode-show-warn-or-err (e face)
-  "Highlight a warning or error E with FACE.
-E is a list of ((MSG-KEY MSG-ARG) BEG LEN OVERRIDE-FACE).
-The last element is optional.  When present, use instead of FACE."
-  (let* ((key (cl-first e))
-         (beg (cl-second e))
-         (end (+ beg (cl-third e)))
-         ;; Don't inadvertently go out of bounds.
-         (beg (max (point-min) (min beg (point-max))))
-         (end (max (point-min) (min end (point-max))))
-         (ovl (make-overlay beg end)))
-    ;; FIXME: Why a mix of overlays and text-properties?
-    (overlay-put ovl 'font-lock-face (or (cl-fourth e) face))
-    (overlay-put ovl 'js2-error t)
-    (put-text-property beg end 'help-echo (js2-get-msg key))
-    (if (fboundp 'cursor-sensor-mode)
-        (put-text-property beg end 'cursor-sensor-functions '(js2-echo-error))
-      (put-text-property beg end 'point-entered #'js2-echo-error))))
-
-(defun js2-remove-overlays ()
-  "Remove overlays from buffer that have a `js2-error' property."
-  (let ((beg (point-min))
-        (end (point-max)))
-    (save-excursion
-      (dolist (o (overlays-in beg end))
-        (when (overlay-get o 'js2-error)
-          (delete-overlay o))))))
-
-(defun js2-mode-apply-deferred-properties ()
-  "Apply fontifications and other text properties recorded during parsing."
-  (when (cl-plusp js2-highlight-level)
-    ;; We defer clearing faces as long as possible to eliminate flashing.
-    (js2-clear-face (point-min) (point-max))
-    ;; Have to reverse the recorded fontifications list so that errors
-    ;; and warnings overwrite the normal fontifications.
-    (dolist (f (nreverse js2-mode-fontifications))
-      (put-text-property (cl-first f) (cl-second f) 'font-lock-face (cl-third f)))
-    (setq js2-mode-fontifications nil))
-  (dolist (p js2-mode-deferred-properties)
-    (apply #'put-text-property p))
-  (setq js2-mode-deferred-properties nil))
-
-(defun js2-mode-show-errors ()
-  "Highlight syntax errors."
-  (when js2-mode-show-parse-errors
-    (dolist (e (js2-ast-root-errors js2-mode-ast))
-      (js2-mode-show-warn-or-err e 'js2-error))))
-
-(defun js2-mode-remove-suppressed-warnings ()
-  "Take suppressed warnings out of the AST warnings list.
-This ensures that the counts and `next-error' are correct."
-  (setf (js2-ast-root-warnings js2-mode-ast)
-        (js2-delete-if
-         (lambda (e)
-           (let ((key (caar e)))
-             (or
-              (and (not js2-strict-trailing-comma-warning)
-                   (string-match "trailing\\.comma" key))
-              (and (not js2-strict-cond-assign-warning)
-                   (string= key "msg.equal.as.assign"))
-              (and js2-missing-semi-one-line-override
-                   (string= key "msg.missing.semi")
-                   (let* ((beg (cl-second e))
-                          (node (js2-node-at-point beg))
-                          (fn (js2-mode-find-parent-fn node))
-                          (body (and fn (js2-function-node-body fn)))
-                          (lc (and body (js2-node-abs-pos body)))
-                          (rc (and lc (+ lc (js2-node-len body)))))
-                     (and fn
-                          (or (null body)
-                              (save-excursion
-                                (goto-char beg)
-                                (and (js2-same-line lc)
-                                     (js2-same-line rc))))))))))
-         (js2-ast-root-warnings js2-mode-ast))))
-
-(defun js2-mode-show-warnings ()
-  "Highlight strict-mode warnings."
-  (when js2-mode-show-strict-warnings
-    (dolist (e (js2-ast-root-warnings js2-mode-ast))
-      (js2-mode-show-warn-or-err e 'js2-warning))))
-
-(defun js2-echo-error (arg1 arg2 &optional _arg3)
-  "Called by point-motion hooks.
-ARG1, ARG2 and ARG3 have different values depending on whether this function
-was found on `point-entered' or in `cursor-sensor-functions'."
-  (let* ((new-point (if (windowp arg1)
-                        ;; Called from cursor-sensor-functions.
-                        (window-point arg1)
-                      ;; Called from point-left.
-                      arg2))
-         (msg (get-text-property new-point 'help-echo)))
-    (when (and (stringp msg)
-               (not (active-minibuffer-window))
-               (not (current-message)))
-      (message msg))))
-
-(defun js2-line-break (&optional _soft)
-  "Break line at point and indent, continuing comment if within one.
-If inside a string, and `js2-concat-multiline-strings' is not
-nil, turn it into concatenation."
-  (interactive)
-  (let ((parse-status (syntax-ppss)))
-    (cond
-     ;; Check if we're inside a string.
-     ((nth 3 parse-status)
-      (if js2-concat-multiline-strings
-          (js2-mode-split-string parse-status)
-        (insert "\n")))
-     ;; Check if inside a block comment.
-     ((nth 4 parse-status)
-      (js2-mode-extend-comment (nth 8 parse-status)))
-     (t
-      (newline-and-indent)))))
-
-(defun js2-mode-split-string (parse-status)
-  "Turn a newline in mid-string into a string concatenation.
-PARSE-STATUS is as documented in `parse-partial-sexp'."
-  (let* ((quote-char (nth 3 parse-status))
-         (at-eol (eq js2-concat-multiline-strings 'eol)))
-    (insert quote-char)
-    (insert (if at-eol " +\n" "\n"))
-    (unless at-eol
-      (insert "+ "))
-    (js2-indent-line)
-    (insert quote-char)
-    (when (eolp)
-      (insert quote-char)
-      (backward-char 1))))
-
-(defun js2-mode-extend-comment (start-pos)
-  "Indent the line and, when inside a comment block, add comment prefix."
-  (let (star single col first-line needs-close)
-    (save-excursion
-      (back-to-indentation)
-      (when (< (point) start-pos)
-        (goto-char start-pos))
-      (cond
-       ((looking-at "\\*[^/]")
-        (setq star t
-              col (current-column)))
-       ((looking-at "/\\*")
-        (setq star t
-              first-line t
-              col (1+ (current-column))))
-       ((looking-at "//")
-        (setq single t
-              col (current-column)))))
-    ;; Heuristic for whether we need to close the comment:
-    ;; if we've got a parse error here, assume it's an unterminated
-    ;; comment.
-    (setq needs-close
-          (or
-           (get-char-property (1- (point)) 'js2-error)
-           ;; The heuristic above doesn't work well when we're
-           ;; creating a comment and there's another one downstream,
-           ;; as our parser thinks this one ends at the end of the
-           ;; next one.  (You can have a /* inside a js block comment.)
-           ;; So just close it if the next non-ws char isn't a *.
-           (and first-line
-                (eolp)
-                (save-excursion
-                  (skip-chars-forward " \t\r\n")
-                  (not (eq (char-after) ?*))))))
-    (delete-horizontal-space)
-    (insert "\n")
-    (cond
-     (star
-      (indent-to col)
-      (insert "* ")
-      (if (and first-line needs-close)
-          (save-excursion
-            (insert "\n")
-            (indent-to col)
-            (insert "*/"))))
-     (single
-      (indent-to col)
-      (insert "// ")))
-    ;; Don't need to extend the comment after all.
-    (js2-indent-line)))
-
-(defun js2-beginning-of-line ()
-  "Toggle point between bol and first non-whitespace char in line.
-Also moves past comment delimiters when inside comments."
-  (interactive)
-  (let (node)
-    (cond
-     ((bolp)
-      (back-to-indentation))
-     ((looking-at "//")
-      (skip-chars-forward "/ \t"))
-     ((and (eq (char-after) ?*)
-           (setq node (js2-comment-at-point))
-           (memq (js2-comment-node-format node) '(jsdoc block))
-           (save-excursion
-             (skip-chars-backward " \t")
-             (bolp)))
-      (skip-chars-forward "\* \t"))
-     (t
-      (goto-char (point-at-bol))))))
-
-(defun js2-end-of-line ()
-  "Toggle point between eol and last non-whitespace char in line."
-  (interactive)
-  (if (eolp)
-      (skip-chars-backward " \t")
-    (goto-char (point-at-eol))))
-
-(defun js2-mode-wait-for-parse (callback)
-  "Invoke CALLBACK when parsing is finished.
-If parsing is already finished, calls CALLBACK immediately."
-  (if (not js2-mode-buffer-dirty-p)
-      (funcall callback)
-    (push callback js2-mode-pending-parse-callbacks)
-    (add-hook 'js2-parse-finished-hook #'js2-mode-parse-finished)))
-
-(defun js2-mode-parse-finished ()
-  "Invoke callbacks in `js2-mode-pending-parse-callbacks'."
-  ;; We can't let errors propagate up, since it prevents the
-  ;; `js2-parse' method from completing normally and returning
-  ;; the ast, which makes things mysteriously not work right.
-  (unwind-protect
-      (dolist (cb js2-mode-pending-parse-callbacks)
-        (condition-case err
-            (funcall cb)
-          (error (message "%s" err))))
-    (setq js2-mode-pending-parse-callbacks nil)))
-
-(defun js2-mode-flag-region (from to flag)
-  "Hide or show text from FROM to TO, according to FLAG.
-If FLAG is nil then text is shown, while if FLAG is t the text is hidden.
-Returns the created overlay if FLAG is non-nil."
-  (remove-overlays from to 'invisible 'js2-outline)
-  (when flag
-    (let ((o (make-overlay from to)))
-      (overlay-put o 'invisible 'js2-outline)
-      (overlay-put o 'isearch-open-invisible
-                   'js2-isearch-open-invisible)
-      o)))
-
-;; Function to be set as an outline-isearch-open-invisible' property
-;; to the overlay that makes the outline invisible (see
-;; `js2-mode-flag-region').
-(defun js2-isearch-open-invisible (_overlay)
-  ;; We rely on the fact that isearch places point on the matched text.
-  (js2-mode-show-element))
-
-(defun js2-mode-invisible-overlay-bounds (&optional pos)
-  "Return cons cell of bounds of folding overlay at POS.
-Returns nil if not found."
-  (let ((overlays (overlays-at (or pos (point))))
-        o)
-    (while (and overlays
-                (not o))
-      (if (overlay-get (car overlays) 'invisible)
-          (setq o (car overlays))
-        (setq overlays (cdr overlays))))
-    (if o
-        (cons (overlay-start o) (overlay-end o)))))
-
-(defun js2-mode-function-at-point (&optional pos)
-  "Return the innermost function node enclosing current point.
-Returns nil if point is not in a function."
-  (let ((node (js2-node-at-point pos)))
-    (while (and node (not (js2-function-node-p node)))
-      (setq node (js2-node-parent node)))
-    (if (js2-function-node-p node)
-        node)))
-
-(defun js2-mode-toggle-element ()
-  "Hide or show the foldable element at the point."
-  (interactive)
-  (let (comment fn pos)
-    (save-excursion
-      (cond
-       ;; /* ... */ comment?
-       ((js2-block-comment-p (setq comment (js2-comment-at-point)))
-        (if (js2-mode-invisible-overlay-bounds
-             (setq pos (+ 3 (js2-node-abs-pos comment))))
-            (progn
-              (goto-char pos)
-              (js2-mode-show-element))
-          (js2-mode-hide-element)))
-       ;; //-comment?
-       ((save-excursion
-          (back-to-indentation)
-          (looking-at js2-mode-//-comment-re))
-        (js2-mode-toggle-//-comment))
-       ;; function?
-       ((setq fn (js2-mode-function-at-point))
-        (setq pos (and (js2-function-node-body fn)
-                       (js2-node-abs-pos (js2-function-node-body fn))))
-        (goto-char (1+ pos))
-        (if (js2-mode-invisible-overlay-bounds)
-            (js2-mode-show-element)
-          (js2-mode-hide-element)))
-       (t
-        (message "Nothing at point to hide or show"))))))
-
-(defun js2-mode-hide-element ()
-  "Fold/hide contents of a block, showing ellipses.
-Show the hidden text with \\[js2-mode-show-element]."
-  (interactive)
-  (if js2-mode-buffer-dirty-p
-      (js2-mode-wait-for-parse #'js2-mode-hide-element))
-  (let (node body beg end)
-    (cond
-     ((js2-mode-invisible-overlay-bounds)
-      (message "already hidden"))
-     (t
-      (setq node (js2-node-at-point))
-      (cond
-       ((js2-block-comment-p node)
-        (js2-mode-hide-comment node))
-       (t
-        (while (and node (not (js2-function-node-p node)))
-          (setq node (js2-node-parent node)))
-        (if (and node
-                 (setq body (js2-function-node-body node)))
-            (progn
-              (setq beg (js2-node-abs-pos body)
-                    end (+ beg (js2-node-len body)))
-              (js2-mode-flag-region (1+ beg) (1- end) 'hide))
-          (message "No collapsable element found at point"))))))))
-
-(defun js2-mode-show-element ()
-  "Show the hidden element at current point."
-  (interactive)
-  (let ((bounds (js2-mode-invisible-overlay-bounds)))
-    (if bounds
-        (js2-mode-flag-region (car bounds) (cdr bounds) nil)
-      (message "Nothing to un-hide"))))
-
-(defun js2-mode-show-all ()
-  "Show all of the text in the buffer."
-  (interactive)
-  (js2-mode-flag-region (point-min) (point-max) nil))
-
-(defun js2-mode-toggle-hide-functions ()
-  (interactive)
-  (if js2-mode-functions-hidden
-      (js2-mode-show-functions)
-    (js2-mode-hide-functions)))
-
-(defun js2-mode-hide-functions ()
-  "Hides all non-nested function bodies in the buffer.
-Use \\[js2-mode-show-all] to reveal them, or \\[js2-mode-show-element]
-to open an individual entry."
-  (interactive)
-  (if js2-mode-buffer-dirty-p
-      (js2-mode-wait-for-parse #'js2-mode-hide-functions))
-  (if (null js2-mode-ast)
-      (message "Oops - parsing failed")
-    (setq js2-mode-functions-hidden t)
-    (js2-visit-ast js2-mode-ast #'js2-mode-function-hider)))
-
-(defun js2-mode-function-hider (n endp)
-  (when (not endp)
-    (let ((tt (js2-node-type n))
-          body beg end)
-      (cond
-       ((and (= tt js2-FUNCTION)
-             (setq body (js2-function-node-body n)))
-        (setq beg (js2-node-abs-pos body)
-              end (+ beg (js2-node-len body)))
-        (js2-mode-flag-region (1+ beg) (1- end) 'hide)
-        nil)   ; don't process children of function
-       (t
-        t))))) ; keep processing other AST nodes
-
-(defun js2-mode-show-functions ()
-  "Un-hide any folded function bodies in the buffer."
-  (interactive)
-  (setq js2-mode-functions-hidden nil)
-  (save-excursion
-    (goto-char (point-min))
-    (while (/= (goto-char (next-overlay-change (point)))
-               (point-max))
-      (dolist (o (overlays-at (point)))
-        (when (and (overlay-get o 'invisible)
-                   (not (overlay-get o 'comment)))
-          (js2-mode-flag-region (overlay-start o) (overlay-end o) nil))))))
-
-(defun js2-mode-hide-comment (n)
-  (let* ((head (if (eq (js2-comment-node-format n) 'jsdoc)
-                   3  ; /**
-                 2))  ; /*
-         (beg (+ (js2-node-abs-pos n) head))
-         (end (- (+ beg (js2-node-len n)) head 2))
-         (o (js2-mode-flag-region beg end 'hide)))
-    (overlay-put o 'comment t)))
-
-(defun js2-mode-toggle-hide-comments ()
-  "Folds all block comments in the buffer.
-Use \\[js2-mode-show-all] to reveal them, or \\[js2-mode-show-element]
-to open an individual entry."
-  (interactive)
-  (if js2-mode-comments-hidden
-      (js2-mode-show-comments)
-    (js2-mode-hide-comments)))
-
-(defun js2-mode-hide-comments ()
-  (interactive)
-  (if js2-mode-buffer-dirty-p
-      (js2-mode-wait-for-parse #'js2-mode-hide-comments))
-  (if (null js2-mode-ast)
-      (message "Oops - parsing failed")
-    (setq js2-mode-comments-hidden t)
-    (dolist (n (js2-ast-root-comments js2-mode-ast))
-      (when (js2-block-comment-p n)
-        (js2-mode-hide-comment n)))
-    (js2-mode-hide-//-comments)))
-
-(defun js2-mode-extend-//-comment (direction)
-  "Find start or end of a block of similar //-comment lines.
-DIRECTION is -1 to look back, 1 to look forward.
-INDENT is the indentation level to match.
-Returns the end-of-line position of the furthest adjacent
-//-comment line with the same indentation as the current line.
-If there is no such matching line, returns current end of line."
-  (let ((pos (point-at-eol))
-        (indent (current-indentation)))
-    (save-excursion
-      (while (and (zerop (forward-line direction))
-                  (looking-at js2-mode-//-comment-re)
-                  (eq indent (length (match-string 1))))
-        (setq pos (point-at-eol)))
-      pos)))
-
-(defun js2-mode-hide-//-comments ()
-  "Fold adjacent 1-line comments, showing only snippet of first one."
-  (let (beg end)
-    (save-excursion
-      (goto-char (point-min))
-      (while (re-search-forward js2-mode-//-comment-re nil t)
-        (setq beg (point)
-              end (js2-mode-extend-//-comment 1))
-        (unless (eq beg end)
-          (overlay-put (js2-mode-flag-region beg end 'hide)
-                       'comment t))
-        (goto-char end)
-        (forward-char 1)))))
-
-(defun js2-mode-toggle-//-comment ()
-  "Fold or un-fold any multi-line //-comment at point.
-Caller should have determined that this line starts with a //-comment."
-  (let* ((beg (point-at-eol))
-         (end beg))
-    (save-excursion
-      (goto-char end)
-      (if (js2-mode-invisible-overlay-bounds)
-          (js2-mode-show-element)
-        ;; else hide the comment
-        (setq beg (js2-mode-extend-//-comment -1)
-              end (js2-mode-extend-//-comment 1))
-        (unless (eq beg end)
-          (overlay-put (js2-mode-flag-region beg end 'hide)
-                       'comment t))))))
-
-(defun js2-mode-show-comments ()
-  "Un-hide any hidden comments, leaving other hidden elements alone."
-  (interactive)
-  (setq js2-mode-comments-hidden nil)
-  (save-excursion
-    (goto-char (point-min))
-    (while (/= (goto-char (next-overlay-change (point)))
-               (point-max))
-      (dolist (o (overlays-at (point)))
-        (when (overlay-get o 'comment)
-          (js2-mode-flag-region (overlay-start o) (overlay-end o) nil))))))
-
-(defun js2-mode-display-warnings-and-errors ()
-  "Turn on display of warnings and errors."
-  (interactive)
-  (setq js2-mode-show-parse-errors t
-        js2-mode-show-strict-warnings t)
-  (js2-reparse 'force))
-
-(defun js2-mode-hide-warnings-and-errors ()
-  "Turn off display of warnings and errors."
-  (interactive)
-  (setq js2-mode-show-parse-errors nil
-        js2-mode-show-strict-warnings nil)
-  (js2-reparse 'force))
-
-(defun js2-mode-toggle-warnings-and-errors ()
-  "Toggle the display of warnings and errors.
-Some users don't like having warnings/errors reported while they type."
-  (interactive)
-  (setq js2-mode-show-parse-errors (not js2-mode-show-parse-errors)
-        js2-mode-show-strict-warnings (not js2-mode-show-strict-warnings))
-  (if (called-interactively-p 'any)
-      (message "warnings and errors %s"
-               (if js2-mode-show-parse-errors
-                   "enabled"
-                 "disabled")))
-  (js2-reparse 'force))
-
-(defun js2-mode-customize ()
-  (interactive)
-  (customize-group 'js2-mode))
-
-(defun js2-mode-forward-sexp (&optional arg)
-  "Move forward across one statement or balanced expression.
-With ARG, do it that many times.  Negative arg -N means
-move backward across N balanced expressions."
-  (interactive "p")
-  (setq arg (or arg 1))
-  (save-restriction
-    (widen) ;; `blink-matching-open' calls `narrow-to-region'
-    (js2-reparse)
-    (let (forward-sexp-function
-          node (start (point)) pos lp rp child)
-      (cond
-       ((js2-string-node-p (js2-node-at-point))
-        (forward-sexp arg))
-       ;; backward-sexp
-       ;; could probably make this better for some cases:
-       ;;  - if in statement block (e.g. function body), go to parent
-       ;;  - infix exprs like (foo in bar) - maybe go to beginning
-       ;;    of infix expr if in the right-side expression?
-       ((and arg (cl-minusp arg))
-        (dotimes (_ (- arg))
-          (js2-backward-sws)
-          (forward-char -1)   ; Enter the node we backed up to.
-          (when (setq node (js2-node-at-point (point) t))
-            (setq pos (js2-node-abs-pos node))
-            (let ((parens (js2-mode-forward-sexp-parens node pos)))
-              (setq lp (car parens)
-                    rp (cdr parens)))
-            (when (and lp (> start lp))
-              (if (and rp (<= start rp))
-                  ;; Between parens, check if there's a child node we can jump.
-                  (when (setq child (js2-node-closest-child node (point) lp t))
-                    (setq pos (js2-node-abs-pos child)))
-                ;; Before both parens.
-                (setq pos lp)))
-            (let ((state (parse-partial-sexp start pos)))
-              (goto-char (if (not (zerop (car state)))
-                             ;; Stumble at the unbalanced paren if < 0, or
-                             ;; jump a bit further if > 0.
-                             (scan-sexps start -1)
-                           pos))))
-          (unless pos (goto-char (point-min)))))
-       (t
-        ;; forward-sexp
-        (dotimes (_ arg)
-          (js2-forward-sws)
-          (when (setq node (js2-node-at-point (point) t))
-            (setq pos (js2-node-abs-pos node))
-            (let ((parens (js2-mode-forward-sexp-parens node pos)))
-              (setq lp (car parens)
-                    rp (cdr parens)))
-            (or
-             (when (and rp (<= start rp))
-               (if (> start lp)
-                   (when (setq child (js2-node-closest-child node (point) rp))
-                     (setq pos (js2-node-abs-end child)))
-                 (setq pos (1+ rp))))
-             ;; No parens or child nodes, looks for the end of the current node.
-             (cl-incf pos (js2-node-len
-                           (if (js2-expr-stmt-node-p (js2-node-parent node))
-                               ;; Stop after the semicolon.
-                               (js2-node-parent node)
-                             node))))
-            (let ((state (save-excursion (parse-partial-sexp start pos))))
-              (goto-char (if (not (zerop (car state)))
-                             (scan-sexps start 1)
-                           pos))))
-          (unless pos (goto-char (point-max)))))))))
-
-(defun js2-mode-forward-sexp-parens (node abs-pos)
-  "Return a cons cell with positions of main parens in NODE."
-  (cond
-   ((or (js2-array-node-p node)
-        (js2-object-node-p node)
-        (js2-comp-node-p node)
-        (memq (aref node 0) '(cl-struct-js2-block-node cl-struct-js2-scope)))
-    (cons abs-pos (+ abs-pos (js2-node-len node) -1)))
-   ((js2-paren-expr-node-p node)
-    (let ((lp (js2-node-lp node))
-          (rp (js2-node-rp node)))
-      (cons (when lp (+ abs-pos lp))
-            (when rp (+ abs-pos rp)))))))
-
-(defun js2-node-closest-child (parent point limit &optional before)
-  (let* ((parent-pos (js2-node-abs-pos parent))
-         (rpoint (- point parent-pos))
-         (rlimit (- limit parent-pos))
-         (min (min rpoint rlimit))
-         (max (max rpoint rlimit))
-         found)
-    (catch 'done
-      (js2-visit-ast
-       parent
-       (lambda (node _end-p)
-         (if (eq node parent)
-             t
-           (let ((pos (js2-node-pos node)) ;; Both relative values.
-                 (end (+ (js2-node-pos node) (js2-node-len node))))
-             (when (and (>= pos min) (<= end max)
-                        (if before (< pos rpoint) (> end rpoint)))
-               (setq found node))
-             (when (> end rpoint)
-               (throw 'done nil)))
-           nil))))
-    found))
-
-(defun js2-errors ()
-  "Return a list of errors found."
-  (and js2-mode-ast
-       (js2-ast-root-errors js2-mode-ast)))
-
-(defun js2-warnings ()
-  "Return a list of warnings found."
-  (and js2-mode-ast
-       (js2-ast-root-warnings js2-mode-ast)))
-
-(defun js2-have-errors-p ()
-  "Return non-nil if any parse errors or warnings were found."
-  (or (js2-errors) (js2-warnings)))
-
-(defun js2-errors-and-warnings ()
-  "Return a copy of the concatenated errors and warnings lists.
-They are appended:  first the errors, then the warnings.
-Entries are of the form (MSG BEG END)."
-  (when js2-mode-ast
-    (append (js2-ast-root-errors js2-mode-ast)
-            (copy-sequence (js2-ast-root-warnings js2-mode-ast)))))
-
-(defun js2-next-error (&optional arg reset)
-  "Move to next parse error.
-Typically invoked via \\[next-error].
-ARG is the number of errors, forward or backward, to move.
-RESET means start over from the beginning."
-  (interactive "p")
-  (if (not (or (js2-errors) (js2-warnings)))
-      (message "No errors")
-    (when reset
-      (goto-char (point-min)))
-    (let* ((errs (js2-errors-and-warnings))
-           (continue t)
-           (start (point))
-           (count (or arg 1))
-           (backward (cl-minusp count))
-           (sorter (if backward '> '<))
-           (stopper (if backward '< '>))
-           (count (abs count))
-           all-errs err)
-      ;; Sort by start position.
-      (setq errs (sort errs (lambda (e1 e2)
-                              (funcall sorter (cl-second e1) (cl-second e2))))
-            all-errs errs)
-      ;; Find nth error with pos > start.
-      (while (and errs continue)
-        (when (funcall stopper (cl-cadar errs) start)
-          (setq err (car errs))
-          (if (zerop (cl-decf count))
-              (setq continue nil)))
-        (setq errs (cdr errs)))
-      ;; Clear for `js2-echo-error'.
-      (message nil)
-      (if err
-          (goto-char (cl-second err))
-        ;; Wrap around to first error.
-        (goto-char (cl-second (car all-errs)))
-        ;; If we were already on it, echo msg again.
-        (if (= (point) start)
-            (js2-echo-error (point) (point)))))))
-
-(defun js2-down-mouse-3 ()
-  "Make right-click move the point to the click location.
-This makes right-click context menu operations a bit more intuitive.
-The point will not move if the region is active, however, to avoid
-destroying the region selection."
-  (interactive)
-  (when (and js2-move-point-on-right-click
-             (not mark-active))
-    (let ((e last-input-event))
-      (ignore-errors
-        (goto-char (cl-cadadr e))))))
-
-(defun js2-mode-create-imenu-index ()
-  "Returns an alist for `imenu--index-alist'. Returns nil on first
-scan if buffer size > `imenu-auto-rescan-maxout'."
-  (when (and (not js2-mode-ast)
-             (<= (buffer-size) imenu-auto-rescan-maxout))
-      (js2-reparse))
-  (when js2-mode-ast
-    ;; if we have an ast but no recorder, they're requesting a rescan
-    (unless js2-imenu-recorder
-      (js2-reparse 'force))
-    (prog1
-        (js2-build-imenu-index)
-      (setq js2-imenu-recorder nil
-            js2-imenu-function-map nil))))
-
-(defun js2-mode-find-tag ()
-  "Replacement for `find-tag-default'.
-`find-tag-default' returns a ridiculous answer inside comments."
-  (let (beg end)
-    (save-excursion
-      (if (looking-at "\\_>")
-          (setq beg (progn (forward-symbol -1) (point))
-                end (progn (forward-symbol 1) (point)))
-        (setq beg (progn (forward-symbol 1) (point))
-              end (progn (forward-symbol -1) (point))))
-      (replace-regexp-in-string
-       "[\"']" ""
-       (buffer-substring-no-properties beg end)))))
-
-(defun js2-mode-forward-sibling ()
-  "Move to the end of the sibling following point in parent.
-Returns non-nil if successful, or nil if there was no following sibling."
-  (let* ((node (js2-node-at-point))
-         (parent (js2-mode-find-enclosing-fn node))
-         sib)
-    (when (setq sib (js2-node-find-child-after (point) parent))
-      (goto-char (+ (js2-node-abs-pos sib)
-                    (js2-node-len sib))))))
-
-(defun js2-mode-backward-sibling ()
-  "Move to the beginning of the sibling node preceding point in parent.
-Parent is defined as the enclosing script or function."
-  (let* ((node (js2-node-at-point))
-         (parent (js2-mode-find-enclosing-fn node))
-         sib)
-    (when (setq sib (js2-node-find-child-before (point) parent))
-      (goto-char (js2-node-abs-pos sib)))))
-
-(defun js2-beginning-of-defun (&optional arg)
-  "Go to line on which current function starts, and return t on success.
-If we're not in a function or already at the beginning of one, go
-to beginning of previous script-level element.
-With ARG N, do that N times. If N is negative, move forward."
-  (setq arg (or arg 1))
-  (if (cl-plusp arg)
-      (let ((parent (js2-node-parent-script-or-fn (js2-node-at-point))))
-        (when (cond
-               ((js2-function-node-p parent)
-                (goto-char (js2-node-abs-pos parent)))
-               (t
-                (js2-mode-backward-sibling)))
-          (if (> arg 1)
-              (js2-beginning-of-defun (1- arg))
-            t)))
-    (when (js2-end-of-defun)
-      (js2-beginning-of-defun (if (>= arg -1) 1 (1+ arg))))))
-
-(defun js2-end-of-defun ()
-  "Go to the char after the last position of the current function
-or script-level element."
-  (let* ((node (js2-node-at-point))
-         (parent (or (and (js2-function-node-p node) node)
-                     (js2-node-parent-script-or-fn node)))
-         script)
-    (unless (js2-function-node-p parent)
-      ;; Use current script-level node, or, if none, the next one.
-      (setq script (or parent node)
-            parent (js2-node-find-child-before (point) script))
-      (when (or (null parent)
-                (>= (point) (+ (js2-node-abs-pos parent)
-                               (js2-node-len parent))))
-        (setq parent (js2-node-find-child-after (point) script))))
-    (when parent
-      (goto-char (+ (js2-node-abs-pos parent)
-                    (js2-node-len parent))))))
-
-(defun js2-mark-defun (&optional allow-extend)
-  "Put mark at end of this function, point at beginning.
-The function marked is the one that contains point.
-
-Interactively, if this command is repeated,
-or (in Transient Mark mode) if the mark is active,
-it marks the next defun after the ones already marked."
-  (interactive "p")
-  (let (extended)
-    (when (and allow-extend
-               (or (and (eq last-command this-command) (mark t))
-                   (and transient-mark-mode mark-active)))
-      (let ((sib (save-excursion
-                   (goto-char (mark))
-                   (if (js2-mode-forward-sibling)
-                       (point)))))
-        (if sib
-            (progn
-              (set-mark sib)
-              (setq extended t))
-          ;; no more siblings - try extending to enclosing node
-          (goto-char (mark t)))))
-   (when (not extended)
-     (let ((node (js2-node-at-point (point) t)) ; skip comments
-           ast fn stmt parent beg end)
-       (when (js2-ast-root-p node)
-         (setq ast node
-               node (or (js2-node-find-child-after (point) node)
-                        (js2-node-find-child-before (point) node))))
-       ;; only mark whole buffer if we can't find any children
-       (if (null node)
-           (setq node ast))
-       (if (js2-function-node-p node)
-           (setq parent node)
-         (setq fn (js2-mode-find-enclosing-fn node)
-               stmt (if (or (null fn)
-                            (js2-ast-root-p fn))
-                        (js2-mode-find-first-stmt node))
-               parent (or stmt fn)))
-       (setq beg (js2-node-abs-pos parent)
-             end (+ beg (js2-node-len parent)))
-       (push-mark beg)
-       (goto-char end)
-       (exchange-point-and-mark)))))
-
-(defun js2-narrow-to-defun ()
-  "Narrow to the function enclosing point."
-  (interactive)
-  (let* ((node (js2-node-at-point (point) t))  ; skip comments
-         (fn (if (js2-script-node-p node)
-                 node
-               (js2-mode-find-enclosing-fn node)))
-         (beg (js2-node-abs-pos fn)))
-    (unless (js2-ast-root-p fn)
-      (narrow-to-region beg (+ beg (js2-node-len fn))))))
-
-(defun js2-jump-to-definition (&optional arg)
-  "Jump to the definition of an object's property, variable or function."
-  (interactive "P")
-  (if (eval-when-compile (fboundp 'xref-push-marker-stack))
-      (xref-push-marker-stack)
-    (ring-insert find-tag-marker-ring (point-marker)))
-  (js2-reparse)
-  (let* ((node (js2-node-at-point))
-         (parent (js2-node-parent node))
-         (names (if (js2-prop-get-node-p parent)
-                    (reverse (let ((temp (js2-compute-nested-prop-get parent)))
-                               (cl-loop for n in temp
-                                        with result = '()
-                                        do (push n result)
-                                        until (equal node n)
-                                        finally return result)))))
-         node-init)
-    (unless (and (js2-name-node-p node)
-                 (not (js2-var-init-node-p parent))
-                 (not (js2-function-node-p parent)))
-      (error "Node is not a supported jump node"))
-    (push (or (and names (pop names))
-              (unless (and (js2-object-prop-node-p parent)
-                           (eq node (js2-object-prop-node-left parent))
-                           (not (js2-node-get-prop parent 'SHORTHAND)))
-                node)
-              (error "Node is not a supported jump node")) names)
-    (setq node-init (js2-search-scope node names))
-
-    ;; todo: display list of results in buffer
-    ;; todo: group found references by buffer
-    (unless node-init
-      (switch-to-buffer
-       (catch 'found
-         (unless arg
-           (mapc (lambda (b)
-                   (with-current-buffer b
-                     (when (derived-mode-p 'js2-mode)
-                       (setq node-init (js2-search-scope js2-mode-ast names))
-                       (if node-init
-                           (throw 'found b)))))
-                 (buffer-list)))
-         nil)))
-    (setq node-init (if (listp node-init) (car node-init) node-init))
-    (unless node-init
-      (pop-tag-mark)
-      (error "No jump location found"))
-    (goto-char (js2-node-abs-pos node-init))))
-
-(defun js2-search-object (node name-node)
-  "Check if object NODE contains element with NAME-NODE."
-  (cl-assert (js2-object-node-p node))
-  ;; Only support name-node and nodes for the time being
-  (cl-loop for elem in (js2-object-node-elems node)
-           for left = (js2-object-prop-node-left elem)
-           if (or (and (js2-name-node-p left)
-                       (equal (js2-name-node-name name-node)
-                              (js2-name-node-name left)))
-                  (and (js2-string-node-p left)
-                       (string= (js2-name-node-name name-node)
-                                (js2-string-node-value left))))
-           return elem))
-
-(defun js2-search-object-for-prop (object prop-names)
-  "Return node in OBJECT that matches PROP-NAMES or nil.
-PROP-NAMES is a list of values representing a path to a value in OBJECT.
-i.e. ('name' 'value') = {name : { value: 3}}"
-  (let (node
-        (temp-object object)
-        (temp t) ;temporay node
-        (names prop-names))
-    (while (and temp names (js2-object-node-p temp-object))
-      (setq temp (js2-search-object temp-object (pop names)))
-      (and (setq node temp)
-         (setq temp-object (js2-object-prop-node-right temp))))
-    (unless names node)))
-
-(defun js2-search-scope (node names)
-  "Searches NODE scope for jump location matching NAMES.
-NAMES is a list of property values to search for. For functions
-and variables NAMES will contain one element."
-  (let (node-init
-        (val (js2-name-node-name (car names))))
-    (setq node-init (js2-get-symbol-declaration node val))
-
-    (when (> (length names) 1)
-
-      ;; Check var declarations
-      (when (and node-init (string= val (js2-name-node-name node-init)))
-        (let ((parent (js2-node-parent node-init))
-              (temp-names names))
-          (pop temp-names) ;; First element is var name
-          (setq node-init (when (js2-var-init-node-p parent)
-                            (js2-search-object-for-prop
-                             (js2-var-init-node-initializer parent)
-                             temp-names)))))
-
-      ;; Check all assign nodes
-      (js2-visit-ast
-       js2-mode-ast
-       (lambda (node endp)
-         (unless endp
-           (if (js2-assign-node-p node)
-               (let ((left (js2-assign-node-left node))
-                     (right (js2-assign-node-right node))
-                     (temp-names names))
-                 (when (js2-prop-get-node-p left)
-                   (let* ((prop-list (js2-compute-nested-prop-get left))
-                          (found (cl-loop for prop in prop-list
-                                          until (not (string= (js2-name-node-name
-                                                               (pop temp-names))
-                                                              (js2-name-node-name prop)))
-                                          if (not temp-names) return prop))
-                          (found-node (or found
-                                          (when (js2-object-node-p right)
-                                            (js2-search-object-for-prop right
-                                                                        temp-names)))))
-                     (if found-node (push found-node node-init))))))
-           t))))
-    node-init))
-
-(defun js2-get-symbol-declaration (node name)
-  "Find scope for NAME from NODE."
-  (let ((scope (js2-get-defining-scope
-          (or (js2-node-get-enclosing-scope node)
-             node) name)))
-    (if scope (js2-symbol-ast-node (js2-scope-get-symbol scope name)))))
-
-(provide 'js2-mode)
-
-;;; js2-mode.el ends here
diff --git a/elpa/js2-mode-20190815.1327/js2-mode.elc b/elpa/js2-mode-20190815.1327/js2-mode.elc
deleted file mode 100644
index 6d50169f..00000000
Binary files a/elpa/js2-mode-20190815.1327/js2-mode.elc and /dev/null differ
diff --git a/elpa/js2-mode-20190815.1327/js2-old-indent.el b/elpa/js2-mode-20190815.1327/js2-old-indent.el
deleted file mode 100644
index 5538736e..00000000
--- a/elpa/js2-mode-20190815.1327/js2-old-indent.el
+++ /dev/null
@@ -1,712 +0,0 @@
-;;; js2-old-indent.el --- Indentation code kept for compatibility
-
-;; Copyright (C) 2015  Free Software Foundation, Inc.
-
-;; This file is part of GNU Emacs.
-
-;; GNU Emacs is free software: you can redistribute it and/or modify
-;; it under the terms of the GNU General Public License as published by
-;; the Free Software Foundation, either version 3 of the License, or
-;; (at your option) any later version.
-
-;; GNU Emacs is distributed in the hope that it will be useful,
-;; but WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-;; GNU General Public License for more details.
-
-;; You should have received a copy of the GNU General Public License
-;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
-
-;;; Commentary:
-
-;; All features of this indentation code have been ported to Emacs's
-;; built-in `js-mode' by now, so we derive from it.  An older
-;; commentary follows.
-
-;; This code is kept for Emacs 24.5 and ealier.
-
-;; This indenter is based on Karl Landström's "javascript.el" indenter.
-;; Karl cleverly deduces that the desired indentation level is often a
-;; function of paren/bracket/brace nesting depth, which can be determined
-;; quickly via the built-in `parse-partial-sexp' function.  His indenter
-;; then does some equally clever checks to see if we're in the context of a
-;; substatement of a possibly braceless statement keyword such as if, while,
-;; or finally.  This approach yields pretty good results.
-
-;; The indenter is often "wrong", however, and needs to be overridden.
-;; The right long-term solution is probably to emulate (or integrate
-;; with) cc-engine, but it's a nontrivial amount of coding.  Even when a
-;; parse tree from `js2-parse' is present, which is not true at the
-;; moment the user is typing, computing indentation is still thousands
-;; of lines of code to handle every possible syntactic edge case.
-
-;; In the meantime, the compromise solution is that we offer a "bounce
-;; indenter", configured with `js2-bounce-indent-p', which cycles the
-;; current line indent among various likely guess points.  This approach
-;; is far from perfect, but should at least make it slightly easier to
-;; move the line towards its desired indentation when manually
-;; overriding Karl's heuristic nesting guesser.
-
-;; I've made miscellaneous tweaks to Karl's code to handle some Ecma
-;; extensions such as `let' and Array comprehensions.  Major kudos to
-;; Karl for coming up with the initial approach, which packs a lot of
-;; punch for so little code. -- Steve
-
-;;; Code:
-
-(require 'sgml-mode)
-
-(defvar js2-language-version)
-
-(declare-function js2-backward-sws "js2-mode")
-(declare-function js2-forward-sws "js2-mode")
-(declare-function js2-same-line "js2-mode")
-
-(defcustom js2-basic-offset (if (and (boundp 'c-basic-offset)
-                                     (numberp c-basic-offset))
-                                c-basic-offset
-                              4)
-  "Number of spaces to indent nested statements.
-Similar to `c-basic-offset'."
-  :group 'js2-mode
-  :safe 'integerp
-  :type 'integer)
-
-(defcustom js2-pretty-multiline-declarations t
-  "Non-nil to line up multiline declarations vertically:
-
-  var a = 10,
-      b = 20,
-      c = 30;
-
-If the value is t, and the first assigned value in the
-declaration is a function/array/object literal spanning several
-lines, it won't be indented additionally:
-
-  var o = {                   var bar = 2,
-    foo: 3          vs.           o = {
-  },                                foo: 3
-      bar = 2;                    };
-
-If the value is `all', it will always be indented additionally:
-
-  var o = {
-        foo: 3
-      };
-
-  var o = {
-        foo: 3
-      },
-      bar = 2;
-
-If the value is `dynamic', it will be indented additionally only
-if the declaration contains more than one variable:
-
-  var o = {
-    foo: 3
-  };
-
-  var o = {
-        foo: 3
-      },
-      bar = 2;"
-  :group 'js2-mode
-  :safe  'symbolp
-  :type 'symbol)
-
-(defcustom js2-indent-switch-body nil
-  "When nil, case labels are indented on the same level as the
-containing switch statement.  Otherwise, all lines inside
-switch statement body are indented one additional level."
-  :type 'boolean
-  :safe 'booleanp
-  :group 'js2-mode)
-
-(defconst js2-possibly-braceless-keywords-re
-  (concat "else[ \t]+if\\|for[ \t]+each\\|"
-          (regexp-opt '("catch" "do" "else" "finally" "for" "if"
-                        "try" "while" "with" "let")))
-  "Regular expression matching keywords that are optionally
-followed by an opening brace.")
-
-(defconst js2-indent-operator-re
-  (concat "[-+*/%<>&^|?:.]\\([^-+*/.]\\|$\\)\\|!?=\\|"
-          (regexp-opt '("in" "instanceof") 'symbols))
-  "Regular expression matching operators that affect indentation
-of continued expressions.")
-
-(defconst js2-declaration-keyword-re
-  (regexp-opt '("var" "let" "const") 'symbols)
-  "Regular expression matching variable declaration keywords.")
-
-(defun js2-re-search-forward-inner (regexp &optional bound count)
-  "Auxiliary function for `js2-re-search-forward'."
-  (let (parse saved-point)
-    (while (> count 0)
-      (re-search-forward regexp bound)
-      (setq parse (if saved-point
-                      (parse-partial-sexp saved-point (point))
-                    (syntax-ppss (point))))
-      (cond ((nth 3 parse)
-             (re-search-forward
-              (concat "\\(\\=\\|[^\\]\\|^\\)" (string (nth 3 parse)))
-              (save-excursion (end-of-line) (point)) t))
-            ((nth 7 parse)
-             (forward-line))
-            ((or (nth 4 parse)
-                 (and (eq (char-before) ?\/) (eq (char-after) ?\*)))
-             (re-search-forward "\\*/"))
-            (t
-             (setq count (1- count))))
-      (setq saved-point (point))))
-  (point))
-
-(defun js2-re-search-forward (regexp &optional bound noerror count)
-  "Search forward but ignore strings and comments.
-Invokes `re-search-forward' but treats the buffer as if strings
-and comments have been removed."
-  (let ((saved-point (point)))
-    (condition-case err
-        (cond ((null count)
-               (js2-re-search-forward-inner regexp bound 1))
-              ((< count 0)
-               (js2-re-search-backward-inner regexp bound (- count)))
-              ((> count 0)
-               (js2-re-search-forward-inner regexp bound count)))
-      (search-failed
-       (goto-char saved-point)
-       (unless noerror
-         (error (error-message-string err)))))))
-
-(defun js2-re-search-backward-inner (regexp &optional bound count)
-  "Auxiliary function for `js2-re-search-backward'."
-  (let (parse)
-    (while (> count 0)
-      (re-search-backward regexp bound)
-      (setq parse (syntax-ppss (point)))
-      (cond ((nth 3 parse)
-             (re-search-backward
-              (concat "\\([^\\]\\|^\\)" (string (nth 3 parse)))
-              (line-beginning-position) t))
-            ((nth 7 parse)
-             (goto-char (nth 8 parse)))
-            ((or (nth 4 parse)
-                 (and (eq (char-before) ?/) (eq (char-after) ?*)))
-             (re-search-backward "/\\*"))
-            (t
-             (setq count (1- count))))))
-  (point))
-
-(defun js2-re-search-backward (regexp &optional bound noerror count)
-  "Search backward but ignore strings and comments.
-Invokes `re-search-backward' but treats the buffer as if strings
-and comments have been removed."
-  (let ((saved-point (point)))
-    (condition-case err
-        (cond ((null count)
-               (js2-re-search-backward-inner regexp bound 1))
-              ((< count 0)
-               (js2-re-search-forward-inner regexp bound (- count)))
-              ((> count 0)
-               (js2-re-search-backward-inner regexp bound count)))
-      (search-failed
-       (goto-char saved-point)
-       (unless noerror
-         (error (error-message-string err)))))))
-
-(defun js2-looking-at-operator-p ()
-  "Return non-nil if text after point is a non-comma operator."
-  (defvar js2-mode-identifier-re)
-  (and (looking-at js2-indent-operator-re)
-       (or (not (eq (char-after) ?:))
-           (save-excursion
-             (and (js2-re-search-backward "[?:{]\\|\\_<case\\_>" nil t)
-                  (eq (char-after) ??))))
-       (not (and
-             (eq (char-after) ?/)
-             (save-excursion
-               (eq (nth 3 (syntax-ppss)) ?/))))
-       (not (and
-             (eq (char-after) ?*)
-             ;; Generator method (possibly using computed property).
-             (looking-at (concat "\\* *\\(?:\\[\\|"
-                                 js2-mode-identifier-re
-                                 " *(\\)"))
-             (save-excursion
-               (js2-backward-sws)
-               ;; We might misindent some expressions that would
-               ;; return NaN anyway.  Shouldn't be a problem.
-               (memq (char-before) '(?, ?} ?{)))))))
-
-(defun js2-continued-expression-p ()
-  "Return non-nil if the current line continues an expression."
-  (save-excursion
-    (back-to-indentation)
-    (if (js2-looking-at-operator-p)
-        (or (not (memq (char-after) '(?- ?+)))
-            (progn
-              (forward-comment (- (point)))
-              (not (memq (char-before) '(?, ?\[ ?\()))))
-      (forward-comment (- (point)))
-      (or (bobp) (backward-char))
-      (when (js2-looking-at-operator-p)
-        (backward-char)
-        (not (looking-at "\\*\\|\\+\\+\\|--\\|/[/*]"))))))
-
-(defun js2-end-of-do-while-loop-p ()
-  "Return non-nil if word after point is `while' of a do-while
-statement, else returns nil. A braceless do-while statement
-spanning several lines requires that the start of the loop is
-indented to the same column as the current line."
-  (interactive)
-  (save-excursion
-    (when (looking-at "\\s-*\\_<while\\_>")
-      (if (save-excursion
-            (skip-chars-backward "[ \t\n]*}")
-            (looking-at "[ \t\n]*}"))
-          (save-excursion
-            (backward-list) (backward-word 1) (looking-at "\\_<do\\_>"))
-        (js2-re-search-backward "\\_<do\\_>" (point-at-bol) t)
-        (or (looking-at "\\_<do\\_>")
-            (let ((saved-indent (current-indentation)))
-              (while (and (js2-re-search-backward "^[ \t]*\\_<" nil t)
-                          (/= (current-indentation) saved-indent)))
-              (and (looking-at "[ \t]*\\_<do\\_>")
-                   (not (js2-re-search-forward
-                         "\\_<while\\_>" (point-at-eol) t))
-                   (= (current-indentation) saved-indent))))))))
-
-(defun js2-multiline-decl-indentation ()
-  "Return the declaration indentation column if the current line belongs
-to a multiline declaration statement.  See `js2-pretty-multiline-declarations'."
-  (let (forward-sexp-function ; use Lisp version
-        at-opening-bracket)
-    (save-excursion
-      (back-to-indentation)
-      (when (not (looking-at js2-declaration-keyword-re))
-        (when (looking-at js2-indent-operator-re)
-          (goto-char (match-end 0))) ; continued expressions are ok
-        (while (and (not at-opening-bracket)
-                    (not (bobp))
-                    (let ((pos (point)))
-                      (save-excursion
-                        (js2-backward-sws)
-                        (or (eq (char-before) ?,)
-                            (and (not (eq (char-before) ?\;))
-                                 (prog2 (skip-syntax-backward ".")
-                                     (looking-at js2-indent-operator-re)
-                                   (js2-backward-sws))
-                                 (not (eq (char-before) ?\;)))
-                            (js2-same-line pos)))))
-          (condition-case _
-              (backward-sexp)
-            (scan-error (setq at-opening-bracket t))))
-        (when (looking-at js2-declaration-keyword-re)
-          (goto-char (match-end 0))
-          (1+ (current-column)))))))
-
-(defun js2-ctrl-statement-indentation ()
-  "Return the proper indentation of current line if it is a control statement.
-Returns an indentation if this line starts the body of a control
-statement without braces, else returns nil."
-  (let (forward-sexp-function)
-    (save-excursion
-      (back-to-indentation)
-      (when (and (not (js2-same-line (point-min)))
-                 (not (looking-at "{"))
-                 (js2-re-search-backward "[[:graph:]]" nil t)
-                 (not (looking-at "[{([]"))
-                 (progn
-                   (forward-char)
-                   (when (= (char-before) ?\))
-                     ;; scan-sexps sometimes throws an error
-                     (ignore-errors (backward-sexp))
-                     (skip-chars-backward " \t" (point-at-bol)))
-                   (let ((pt (point)))
-                     (back-to-indentation)
-                     (when (looking-at "}[ \t]*")
-                       (goto-char (match-end 0)))
-                     (and (looking-at js2-possibly-braceless-keywords-re)
-                          (= (match-end 0) pt)
-                          (not (js2-end-of-do-while-loop-p))))))
-        (+ (current-indentation) js2-basic-offset)))))
-
-(defun js2-indent-in-array-comp (parse-status)
-  "Return non-nil if we think we're in an array comprehension.
-In particular, return the buffer position of the first `for' kwd."
-  (let ((bracket (nth 1 parse-status))
-        (end (point)))
-    (when bracket
-      (save-excursion
-        (goto-char bracket)
-        (when (looking-at "\\[")
-          (forward-char 1)
-          (js2-forward-sws)
-          (if (looking-at "[[{]")
-              (let (forward-sexp-function) ; use Lisp version
-                (forward-sexp)             ; skip destructuring form
-                (js2-forward-sws)
-                (if (and (/= (char-after) ?,) ; regular array
-                         (looking-at "for"))
-                    (match-beginning 0)))
-            ;; to skip arbitrary expressions we need the parser,
-            ;; so we'll just guess at it.
-            (if (and (> end (point)) ; not empty literal
-                     (re-search-forward "[^,]]* \\(for\\) " end t)
-                     ;; not inside comment or string literal
-                     (let ((state (parse-partial-sexp bracket (point))))
-                       (and (= 1 (car state))
-                            (not (nth 8 state)))))
-                (match-beginning 1))))))))
-
-(defun js2-array-comp-indentation (parse-status for-kwd)
-  (if (js2-same-line for-kwd)
-      ;; first continuation line
-      (save-excursion
-        (goto-char (nth 1 parse-status))
-        (forward-char 1)
-        (skip-chars-forward " \t")
-        (current-column))
-    (save-excursion
-      (goto-char for-kwd)
-      (current-column))))
-
-(defun js2-maybe-goto-declaration-keyword-end (bracket)
-  "Helper function for `js2-proper-indentation'.
-Depending on the value of `js2-pretty-multiline-declarations',
-move point to the end of a variable declaration keyword so that
-indentation is aligned to that column."
-  (cond
-   ((eq js2-pretty-multiline-declarations 'all)
-    (when (looking-at js2-declaration-keyword-re)
-      (goto-char (1+ (match-end 0)))))
-   ((eq js2-pretty-multiline-declarations 'dynamic)
-    (let (declaration-keyword-end
-          at-closing-bracket-p
-          comma-p)
-      (when (looking-at js2-declaration-keyword-re)
-        ;; Preserve the match data lest it somehow be overridden.
-        (setq declaration-keyword-end (match-end 0))
-        (save-excursion
-          (goto-char bracket)
-          (setq at-closing-bracket-p
-                ;; Handle scan errors gracefully.
-                (condition-case nil
-                    (progn
-                      ;; Use the regular `forward-sexp-function' because the
-                      ;; normal one for this mode uses the AST.
-                      (let (forward-sexp-function)
-                        (forward-sexp))
-                      t)
-                  (error nil)))
-          (when at-closing-bracket-p
-            (js2-forward-sws)
-            (setq comma-p (looking-at-p ","))))
-        (when comma-p
-          (goto-char (1+ declaration-keyword-end))))))))
-
-(cl-defun js2-proper-indentation (parse-status)
-  "Return the proper indentation for the current line."
-  (save-excursion
-    (back-to-indentation)
-    (when (nth 4 parse-status)
-      (cl-return-from js2-proper-indentation (js2--comment-indent parse-status)))
-    (let* ((at-closing-bracket (looking-at "[]})]"))
-           (same-indent-p (or at-closing-bracket
-                              (looking-at "\\_<case\\_>[^:]")
-                              (and (looking-at "\\_<default:")
-                                   (save-excursion
-                                     (js2-backward-sws)
-                                     (not (memq (char-before) '(?, ?{)))))))
-           (continued-expr-p (js2-continued-expression-p))
-           (declaration-indent (and js2-pretty-multiline-declarations
-                                    (js2-multiline-decl-indentation)))
-           (bracket (nth 1 parse-status))
-           beg indent)
-      (cond
-       ;; indent array comprehension continuation lines specially
-       ((and bracket
-             (>= js2-language-version 170)
-             (not (js2-same-line bracket))
-             (setq beg (js2-indent-in-array-comp parse-status))
-             (>= (point) (save-excursion
-                           (goto-char beg)
-                           (point-at-bol)))) ; at or after first loop?
-        (js2-array-comp-indentation parse-status beg))
-
-       ((js2-ctrl-statement-indentation))
-
-       ((and declaration-indent continued-expr-p)
-        (+ declaration-indent js2-basic-offset))
-
-       (declaration-indent)
-
-       (bracket
-        (goto-char bracket)
-        (cond
-         ((looking-at "[({[][ \t]*\\(/[/*]\\|$\\)")
-          (when (save-excursion (skip-chars-backward " \t\n)")
-                                (looking-at ")"))
-            (backward-list))
-          (back-to-indentation)
-          (js2-maybe-goto-declaration-keyword-end bracket)
-          (setq indent
-                (cond (same-indent-p
-                       (current-column))
-                      (continued-expr-p
-                       (+ (current-column) (* 2 js2-basic-offset)))
-                      (t
-                       (+ (current-column) js2-basic-offset))))
-          (if (and js2-indent-switch-body
-                   (not at-closing-bracket)
-                   (looking-at "\\_<switch\\_>"))
-              (+ indent js2-basic-offset)
-            indent))
-         (t
-          (unless same-indent-p
-            (forward-char)
-            (skip-chars-forward " \t"))
-          (current-column))))
-
-       (continued-expr-p js2-basic-offset)
-
-       (t 0)))))
-
-(defun js2--comment-indent (parse-status)
-  "Indentation inside a multi-line block comment continuation line."
-  (save-excursion
-    (goto-char (nth 8 parse-status))
-    (if (looking-at "/\\*")
-        (+ 1 (current-column))
-      0)))
-
-(defun js2-indent-line (&optional bounce-backwards)
-  "Indent the current line as JavaScript source text."
-  (interactive)
-  (let (parse-status offset
-        ;; Don't whine about errors/warnings when we're indenting.
-        ;; This has to be set before calling parse-partial-sexp below.
-        (inhibit-point-motion-hooks t))
-    (setq parse-status (save-excursion
-                         (syntax-ppss (point-at-bol)))
-          offset (- (point) (save-excursion
-                              (back-to-indentation)
-                              (point))))
-    ;; Don't touch multiline strings.
-    (unless (nth 3 parse-status)
-      (indent-line-to (js2-proper-indentation parse-status))
-      (when (cl-plusp offset)
-        (forward-char offset)))))
-
-;;; JSX Indentation
-
-;; The following JSX indentation code is copied basically verbatim from js.el at
-;; 958da7f, except that the prefixes on the functions/variables are changed.
-
-(defsubst js2--jsx-find-before-tag ()
-  "Find where JSX starts.
-
-Assume JSX appears in the following instances:
-- Inside parentheses, when returned or as the first argument
-  to a function, and after a newline
-- When assigned to variables or object properties, but only
-  on a single line
-- As the N+1th argument to a function
-
-This is an optimized version of (re-search-backward \"[(,]\n\"
-nil t), except set point to the end of the match.  This logic
-executes up to the number of lines in the file, so it should be
-really fast to reduce that impact."
-  (let (pos)
-    (while (and (> (point) (point-min))
-                (not (progn
-                       (end-of-line 0)
-                       (when (or (eq (char-before) 40)   ; (
-                                 (eq (char-before) 44))  ; ,
-                         (setq pos (1- (point))))))))
-    pos))
-
-(defconst js2--jsx-end-tag-re
-  (concat "</" sgml-name-re ">\\|/>")
-  "Find the end of a JSX element.")
-
-(defconst js2--jsx-after-tag-re "[),]"
-  "Find where JSX ends.
-This complements the assumption of where JSX appears from
-`js--jsx-before-tag-re', which see.")
-
-(defun js2--jsx-indented-element-p ()
-  "Determine if/how the current line should be indented as JSX.
-
-Return `first' for the first JSXElement on its own line.
-Return `nth' for subsequent lines of the first JSXElement.
-Return `expression' for an embedded JS expression.
-Return `after' for anything after the last JSXElement.
-Return nil for non-JSX lines.
-
-Currently, JSX indentation supports the following styles:
-
-- Single-line elements (indented like normal JS):
-
-  var element = <div></div>;
-
-- Multi-line elements (enclosed in parentheses):
-
-  function () {
-    return (
-      <div>
-        <div></div>
-      </div>
-    );
- }
-
-- Function arguments:
-
-  React.render(
-    <div></div>,
-    document.querySelector('.root')
-  );"
-  (let ((current-pos (point))
-        (current-line (line-number-at-pos))
-        last-pos
-        before-tag-pos before-tag-line
-        tag-start-pos tag-start-line
-        tag-end-pos tag-end-line
-        after-tag-line
-        parens paren type)
-    (save-excursion
-      (and
-       ;; Determine if we're inside a jsx element
-       (progn
-         (end-of-line)
-         (while (and (not tag-start-pos)
-                     (setq last-pos (js2--jsx-find-before-tag)))
-           (while (forward-comment 1))
-           (when (= (char-after) 60) ; <
-             (setq before-tag-pos last-pos
-                   tag-start-pos (point)))
-           (goto-char last-pos))
-         tag-start-pos)
-       (progn
-         (setq before-tag-line (line-number-at-pos before-tag-pos)
-               tag-start-line (line-number-at-pos tag-start-pos))
-         (and
-          ;; A "before" line which also starts an element begins with js, so
-          ;; indent it like js
-          (> current-line before-tag-line)
-          ;; Only indent the jsx lines like jsx
-          (>= current-line tag-start-line)))
-       (cond
-        ;; Analyze bounds if there are any
-        ((progn
-           (while (and (not tag-end-pos)
-                       (setq last-pos (re-search-forward js2--jsx-end-tag-re nil t)))
-             (while (forward-comment 1))
-             (when (looking-at js2--jsx-after-tag-re)
-               (setq tag-end-pos last-pos)))
-           tag-end-pos)
-         (setq tag-end-line (line-number-at-pos tag-end-pos)
-               after-tag-line (line-number-at-pos after-tag-line))
-         (or (and
-              ;; Ensure we're actually within the bounds of the jsx
-              (<= current-line tag-end-line)
-              ;; An "after" line which does not end an element begins with
-              ;; js, so indent it like js
-              (<= current-line after-tag-line))
-             (and
-              ;; Handle another case where there could be e.g. comments after
-              ;; the element
-              (> current-line tag-end-line)
-              (< current-line after-tag-line)
-              (setq type 'after))))
-        ;; They may not be any bounds (yet)
-        (t))
-       ;; Check if we're inside an embedded multi-line js expression
-       (cond
-        ((not type)
-         (goto-char current-pos)
-         (end-of-line)
-         (setq parens (nth 9 (syntax-ppss)))
-         (while (and parens (not type))
-           (setq paren (car parens))
-           (cond
-            ((and (>= paren tag-start-pos)
-                  ;; Curly bracket indicates the start of an embedded expression
-                  (= (char-after paren) 123) ; {
-                  ;; The first line of the expression is indented like sgml
-                  (> current-line (line-number-at-pos paren))
-                  ;; Check if within a closing curly bracket (if any)
-                  ;; (exclusive, as the closing bracket is indented like sgml)
-                  (cond
-                   ((progn
-                      (goto-char paren)
-                      (ignore-errors (let (forward-sexp-function)
-                                       (forward-sexp))))
-                    (< current-line (line-number-at-pos)))
-                   (t)))
-             ;; Indicate this guy will be indented specially
-             (setq type 'expression))
-            (t (setq parens (cdr parens)))))
-         t)
-        (t))
-       (cond
-        (type)
-        ;; Indent the first jsx thing like js so we can indent future jsx things
-        ;; like sgml relative to the first thing
-        ((= current-line tag-start-line) 'first)
-        ('nth))))))
-
-(defmacro js2--as-sgml (&rest body)
-  "Execute BODY as if in sgml-mode."
-  `(with-syntax-table sgml-mode-syntax-table
-     (let (forward-sexp-function
-           parse-sexp-lookup-properties)
-       ,@body)))
-
-(defun js2--expression-in-sgml-indent-line ()
-  "Indent the current line as JavaScript or SGML (whichever is farther)."
-  (let* (indent-col
-         (savep (point))
-         ;; Don't whine about errors/warnings when we're indenting.
-         ;; This has to be set before calling parse-partial-sexp below.
-         (inhibit-point-motion-hooks t)
-         (parse-status (save-excursion
-                         (syntax-ppss (point-at-bol)))))
-    ;; Don't touch multiline strings.
-    (unless (nth 3 parse-status)
-      (setq indent-col (save-excursion
-                         (back-to-indentation)
-                         (if (>= (point) savep) (setq savep nil))
-                         (js2--as-sgml (sgml-calculate-indent))))
-      (if (null indent-col)
-          'noindent
-        ;; Use whichever indentation column is greater, such that the sgml
-        ;; column is effectively a minimum
-        (setq indent-col (max (js2-proper-indentation parse-status)
-                              (+ indent-col js2-basic-offset)))
-        (if savep
-            (save-excursion (indent-line-to indent-col))
-          (indent-line-to indent-col))))))
-
-(defun js2-jsx-indent-line ()
-  "Indent the current line as JSX (with SGML offsets).
-i.e., customize JSX element indentation with `sgml-basic-offset'
-et al."
-  (interactive)
-  (let ((indentation-type (js2--jsx-indented-element-p)))
-    (cond
-     ((eq indentation-type 'expression)
-      (js2--expression-in-sgml-indent-line))
-     ((or (eq indentation-type 'first)
-          (eq indentation-type 'after))
-      ;; Don't treat this first thing as a continued expression (often a "<" or
-      ;; ">" causes this misinterpretation)
-      (cl-letf (((symbol-function #'js2-continued-expression-p) 'ignore))
-        (js2-indent-line)))
-     ((eq indentation-type 'nth)
-      (js2--as-sgml (sgml-indent-line)))
-     (t (js2-indent-line)))))
-
-(provide 'js2-old-indent)
-
-;;; js2-old-indent.el ends here
diff --git a/elpa/js2-mode-20190815.1327/js2-old-indent.elc b/elpa/js2-mode-20190815.1327/js2-old-indent.elc
deleted file mode 100644
index 73b33992..00000000
Binary files a/elpa/js2-mode-20190815.1327/js2-old-indent.elc and /dev/null differ
diff --git a/elpa/js2-refactor-20190630.2108/js2-refactor-autoloads.el b/elpa/js2-refactor-20190630.2108/js2-refactor-autoloads.el
deleted file mode 100644
index 87f8be7b..00000000
--- a/elpa/js2-refactor-20190630.2108/js2-refactor-autoloads.el
+++ /dev/null
@@ -1,123 +0,0 @@
-;;; js2-refactor-autoloads.el --- automatically extracted autoloads
-;;
-;;; Code:
-
-(add-to-list 'load-path (directory-file-name
-                         (or (file-name-directory #$) (car load-path))))
-
-
-;;;### (autoloads nil "js2-refactor" "js2-refactor.el" (0 0 0 0))
-;;; Generated autoloads from js2-refactor.el
-
-(autoload 'js2-refactor-mode "js2-refactor" "\
-Minor mode providing JavaScript refactorings.
-
-\(fn &optional ARG)" t nil)
-
-(autoload 'js2r-add-keybindings-with-prefix "js2-refactor" "\
-Add js2r keybindings using the prefix PREFIX.
-
-\(fn PREFIX)" nil nil)
-
-(autoload 'js2r-add-keybindings-with-modifier "js2-refactor" "\
-Add js2r keybindings using the modifier MODIFIER.
-
-\(fn MODIFIER)" nil nil)
-
-(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "js2-refactor" '("js2")))
-
-;;;***
-
-;;;### (autoloads nil "js2r-conditionals" "js2r-conditionals.el"
-;;;;;;  (0 0 0 0))
-;;; Generated autoloads from js2r-conditionals.el
-
-(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "js2r-conditionals" '("js2r-ternary-to-if")))
-
-;;;***
-
-;;;### (autoloads nil "js2r-conveniences" "js2r-conveniences.el"
-;;;;;;  (0 0 0 0))
-;;; Generated autoloads from js2r-conveniences.el
-
-(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "js2r-conveniences" '("js2r-" "move-line-")))
-
-;;;***
-
-;;;### (autoloads nil "js2r-formatting" "js2r-formatting.el" (0 0
-;;;;;;  0 0))
-;;; Generated autoloads from js2r-formatting.el
-
-(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "js2r-formatting" '("js2r-")))
-
-;;;***
-
-;;;### (autoloads nil "js2r-functions" "js2r-functions.el" (0 0 0
-;;;;;;  0))
-;;; Generated autoloads from js2r-functions.el
-
-(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "js2r-functions" '("js2r-")))
-
-;;;***
-
-;;;### (autoloads nil "js2r-helpers" "js2r-helpers.el" (0 0 0 0))
-;;; Generated autoloads from js2r-helpers.el
-
-(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "js2r-helpers" '("js2r--")))
-
-;;;***
-
-;;;### (autoloads nil "js2r-iife" "js2r-iife.el" (0 0 0 0))
-;;; Generated autoloads from js2r-iife.el
-
-(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "js2r-iife" '("js2r-")))
-
-;;;***
-
-;;;### (autoloads nil "js2r-paredit" "js2r-paredit.el" (0 0 0 0))
-;;; Generated autoloads from js2r-paredit.el
-
-(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "js2r-paredit" '("js2r-")))
-
-;;;***
-
-;;;### (autoloads nil "js2r-vars" "js2r-vars.el" (0 0 0 0))
-;;; Generated autoloads from js2r-vars.el
-
-(autoload 'js2r-extract-var "js2r-vars" "\
-
-
-\(fn)" t nil)
-
-(autoload 'js2r-extract-let "js2r-vars" "\
-
-
-\(fn)" t nil)
-
-(autoload 'js2r-extract-const "js2r-vars" "\
-
-
-\(fn)" t nil)
-
-(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "js2r-vars" '("js2r-" "current-line-contents")))
-
-;;;***
-
-;;;### (autoloads nil "js2r-wrapping" "js2r-wrapping.el" (0 0 0 0))
-;;; Generated autoloads from js2r-wrapping.el
-
-(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "js2r-wrapping" '("js2r-")))
-
-;;;***
-
-;;;### (autoloads nil nil ("js2-refactor-pkg.el") (0 0 0 0))
-
-;;;***
-
-;; Local Variables:
-;; version-control: never
-;; no-byte-compile: t
-;; no-update-autoloads: t
-;; coding: utf-8
-;; End:
-;;; js2-refactor-autoloads.el ends here
diff --git a/elpa/js2-refactor-20190630.2108/js2-refactor-pkg.el b/elpa/js2-refactor-20190630.2108/js2-refactor-pkg.el
deleted file mode 100644
index f239fff1..00000000
--- a/elpa/js2-refactor-20190630.2108/js2-refactor-pkg.el
+++ /dev/null
@@ -1,10 +0,0 @@
-(define-package "js2-refactor" "20190630.2108" "A JavaScript refactoring library for emacs."
-  '((js2-mode "20101228")
-    (s "1.9.0")
-    (multiple-cursors "1.0.0")
-    (dash "1.0.0")
-    (s "1.0.0")
-    (yasnippet "0.9.0.1")))
-;; Local Variables:
-;; no-byte-compile: t
-;; End:
diff --git a/elpa/js2-refactor-20190630.2108/js2-refactor.el b/elpa/js2-refactor-20190630.2108/js2-refactor.el
deleted file mode 100644
index 02171188..00000000
--- a/elpa/js2-refactor-20190630.2108/js2-refactor.el
+++ /dev/null
@@ -1,238 +0,0 @@
-;;; js2-refactor.el --- The beginnings of a JavaScript refactoring library in emacs.    -*- lexical-binding: t; -*-
-
-;; Copyright (C) 2012-2014 Magnar Sveen
-;; Copyright (C) 2015-2016 Magnar Sveen and Nicolas Petton
-
-;; Author: Magnar Sveen <magnars@gmail.com>,
-;;         Nicolas Petton <nicolas@petton.fr>
-;; Keywords: conveniences
-
-;; This program is free software; you can redistribute it and/or modify
-;; it under the terms of the GNU General Public License as published by
-;; the Free Software Foundation, either version 3 of the License, or
-;; (at your option) any later version.
-
-;; This program is distributed in the hope that it will be useful,
-;; but WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-;; GNU General Public License for more details.
-
-;; You should have received a copy of the GNU General Public License
-;; along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-;;; Commentary:
-
-;; This is a collection of small refactoring functions to further the idea of a
-;; JavaScript IDE in Emacs that started with js2-mode.
-
-;; ## Installation
-
-;; Start by installing the dependencies:
-
-;;  * js2-mode https://github.com/mooz/js2-mode/
-;;  * dash https://github.com/magnars/dash.el
-;;  * multiple-cursors https://github.com/magnars/multiple-cursors.el
-
-;; It is also recommended to get
-;; [expand-region](https://github.com/magnars/expand-region.el) to more easily mark
-;; vars, method calls and functions for refactorings.
-
-;; Then add this to your Emacs settings:
-
-;;     (require 'js2-refactor)
-;;     (add-hook 'js2-mode-hook #'js2-refactor-mode)
-;;     (js2r-add-keybindings-with-prefix "C-c C-m")
-
-;; Note: I am working on a smoother installation path through package.el,
-;; but I haven't had the time to whip this project into that sort of
-;; structure - yet.
-
-;; ## Usage
-
-;; All refactorings start with `C-c C-m` and then a two-letter mnemonic shortcut.
-
-;;  * `ee` is `expand-node-at-point`: Expand bracketed list according to node type at point (array, object, function, call args).
-;;  * `cc` is `contract-node-at-point`: Contract bracketed list according to node type at point (array, object, function, call args).
-;;  * `ef` is `extract-function`: Extracts the marked expressions out into a new named function.
-;;  * `em` is `extract-method`: Extracts the marked expressions out into a new named method in an object literal.
-;;  * `tf` is `toggle-function-expression-and-declaration`: Toggle between function name() {} and var name = function ();
-;;  * `ta` is `toggle-arrow-function-and-expression`: Toggle between function expression to arrow function.
-;;  * `ts` is `toggle-function-async`: Toggle between an async and a regular function.
-;;  * `ip` is `introduce-parameter`: Changes the marked expression to a parameter in a local function.
-;;  * `lp` is `localize-parameter`: Changes a parameter to a local var in a local function.
-;;  * `wi` is `wrap-buffer-in-iife`: Wraps the entire buffer in an immediately invoked function expression
-;;  * `ig` is `inject-global-in-iife`: Creates a shortcut for a marked global by injecting it in the wrapping immediately invoked function expression
-;;  * `ag` is `add-to-globals-annotation`: Creates a `/*global */` annotation if it is missing, and adds the var at point to it.
-;;  * `ev` is `extract-var`: Takes a marked expression and replaces it with a var.
-;;  * `el` is `extract-var`: Takes a marked expression and replaces it with a let.
-;;  * `ec` is `extract-var`: Takes a marked expression and replaces it with a const.
-;;  * `iv` is `inline-var`: Replaces all instances of a variable with its initial value.
-;;  * `rv` is `rename-var`: Renames the variable on point and all occurrences in its lexical scope.
-;;  * `vt` is `var-to-this`: Changes local `var a` to be `this.a` instead.
-;;  * `ao` is `arguments-to-object`: Replaces arguments to a function call with an object literal of named arguments.
-;;  * `3i` is `ternary-to-if`: Converts ternary operator to if-statement.
-;;  * `sv` is `split-var-declaration`: Splits a `var` with multiple vars declared, into several `var` statements.
-;;  * `ss` is `split-string`: Splits a `string`.
-;;  * `st` is `string-to-template`: Converts a `string` into a template string.
-;;  * `uw` is `unwrap`: Replaces the parent statement with the selected region.
-;;  * `lt` is `log-this`: Adds a console.log() statement for what is at point (or region).  With a prefix argument, use JSON pretty-printing.
-;;  * `dt` is `debug-this`: Adds a debug() statement for what is at point (or region).
-;;  * `sl` is `forward-slurp`: Moves the next statement into current function, if-statement, for-loop or while-loop.
-;;  * `ba` is `forward-barf`: Moves the last child out of current function, if-statement, for-loop or while-loop.
-;;  * `k` is `kill`: Kills to the end of the line, but does not cross semantic boundaries.
-
-;; There are also some minor conveniences bundled:
-
-;;  * `C-S-down` and `C-S-up` moves the current line up or down.  If the line is an
-;;    element in an object or array literal, it makes sure that the commas are
-;;    still correctly placed.
-;;  * `k` `kill-line`: Like `kill-line` but respecting the AST.
-
-;; ## Todo
-
-;; A list of some wanted improvements for the current refactorings.
-
-;;  * expand- and contract-array: should work recursively with nested object literals and nested arrays.
-;;  * expand- and contract-function: should deal better with nested object literals, array declarations, and statements terminated only by EOLs (without semicolons).
-;;  * wrap-buffer-in-iife: should skip comments and namespace initializations at buffer start.
-;;  * extract-variable: could end with a query-replace of the expression in its scope.
-
-;; ## Contributions
-
-;; * [Matt Briggs](https://github.com/mbriggs) contributed `js2r-add-to-globals-annotation`
-;; * [Alex Chamberlain](https://github.com/apchamberlain) contributed contracting and expanding arrays and functions.
-;; * [Nicolas Petton](https://github.com/NicolasPetton) contributed `js2r-kill`
-;; Thanks!
-
-;; ## Contribute
-
-;; This project is still in its infancy, and everything isn't quite sorted out
-;; yet.  If you're eager to contribute, please add an issue here on github and we
-;; can discuss your changes a little before diving into the elisp :-).
-
-;; To fetch the test dependencies:
-
-;;     $ cd /path/to/multiple-cursors
-;;     $ git submodule init
-;;     $ git submodule update
-
-;; Run the tests with:
-
-;;     $ ./util/ecukes/ecukes features
-
-;;; Code:
-
-(require 'js2-mode)
-(require 'js2r-helpers)
-(require 'js2r-formatting)
-(require 'js2r-iife)
-(require 'js2r-vars)
-(require 'js2r-functions)
-(require 'js2r-wrapping)
-(require 'js2r-conditionals)
-(require 'js2r-conveniences)
-(require 'js2r-paredit)
-
-(defvar js2-refactor-mode-map
-  (make-sparse-keymap)
-  "Keymap for js2-refactor.")
-
-(defvar js2-refactor-keybinding-prefix
-  nil
-  "Store keybinding prefix used by js2-refactor.")
-
-;;;###autoload
-(define-minor-mode js2-refactor-mode
-  "Minor mode providing JavaScript refactorings."
-  :lighter " js2r"
-  :keymap js2-refactor-mode-map
-  (when js2-refactor-mode
-    (yas-minor-mode-on)))
-
-;;; Settings ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(defgroup js2-refactor nil
-  "Minor mode providing JavaScript refactorings."
-  :group 'tools
-  :prefix "js2r-"
-  :link '(url-link :tag "Repository" "https://github.com/magnars/js2-refactor.el"))
-
-(defcustom js2r-use-strict nil
-  "When non-nil, js2r inserts strict declarations in IIFEs."
-  :group 'js2-refactor
-  :type 'boolean)
-
-(defcustom js2r-prefered-quote-type 1
-  "The prefered quote style for strings."
-  :group 'js2-refactor
-  :type '(choice (const :tag "Double" 1)
-                 (const :tag "Single" 2)))
-
-(defcustom js2r-always-insert-parens-around-arrow-function-params nil
-  "When non-nil, js2r always inserts parenthesis around arrow function params.
-This only affects arrow functions with one parameter."
-  :group 'js2-refactor
-  :type 'boolean)
-
-(defcustom js2r-prefer-let-over-var nil
-  "When non-nil, js2r uses let constructs over var when performing refactorings."
-  :group 'js2-refactor
-  :type 'boolean)
-
-(defcustom js2r-log-before-point  nil
-  "When non-nil, js2r inserts logging and debug statements before point.
-When nil, logging and debug statements are inserted after point,
-unless point is in a return statement."
-  :group 'js2-refactor
-  :type 'boolean)
-
-;;; Keybindings ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(defun js2r--add-keybindings (key-fn)
-  "Add js2r refactoring keybindings to `js2-mode-map' using KEY-FN to create each keybinding."
-  (define-key js2-refactor-mode-map (funcall key-fn "ee") #'js2r-expand-node-at-point)
-  (define-key js2-refactor-mode-map (funcall key-fn "cc") #'js2r-contract-node-at-point)
-  (define-key js2-refactor-mode-map (funcall key-fn "wi") #'js2r-wrap-buffer-in-iife)
-  (define-key js2-refactor-mode-map (funcall key-fn "ig") #'js2r-inject-global-in-iife)
-  (define-key js2-refactor-mode-map (funcall key-fn "ev") #'js2r-extract-var)
-  (define-key js2-refactor-mode-map (funcall key-fn "el") #'js2r-extract-let)
-  (define-key js2-refactor-mode-map (funcall key-fn "ec") #'js2r-extract-const)
-  (define-key js2-refactor-mode-map (funcall key-fn "iv") #'js2r-inline-var)
-  (define-key js2-refactor-mode-map (funcall key-fn "rv") #'js2r-rename-var)
-  (define-key js2-refactor-mode-map (funcall key-fn "vt") #'js2r-var-to-this)
-  (define-key js2-refactor-mode-map (funcall key-fn "ag") #'js2r-add-to-globals-annotation)
-  (define-key js2-refactor-mode-map (funcall key-fn "sv") #'js2r-split-var-declaration)
-  (define-key js2-refactor-mode-map (funcall key-fn "ss") #'js2r-split-string)
-  (define-key js2-refactor-mode-map (funcall key-fn "st") #'js2r-string-to-template)
-  (define-key js2-refactor-mode-map (funcall key-fn "ef") #'js2r-extract-function)
-  (define-key js2-refactor-mode-map (funcall key-fn "em") #'js2r-extract-method)
-  (define-key js2-refactor-mode-map (funcall key-fn "ip") #'js2r-introduce-parameter)
-  (define-key js2-refactor-mode-map (funcall key-fn "lp") #'js2r-localize-parameter)
-  (define-key js2-refactor-mode-map (funcall key-fn "tf") #'js2r-toggle-function-expression-and-declaration)
-  (define-key js2-refactor-mode-map (funcall key-fn "ta") #'js2r-toggle-arrow-function-and-expression)
-  (define-key js2-refactor-mode-map (funcall key-fn "ts") #'js2r-toggle-function-async)
-  (define-key js2-refactor-mode-map (funcall key-fn "ao") #'js2r-arguments-to-object)
-  (define-key js2-refactor-mode-map (funcall key-fn "uw") #'js2r-unwrap)
-  (define-key js2-refactor-mode-map (funcall key-fn "wl") #'js2r-wrap-in-for-loop)
-  (define-key js2-refactor-mode-map (funcall key-fn "3i") #'js2r-ternary-to-if)
-  (define-key js2-refactor-mode-map (funcall key-fn "lt") #'js2r-log-this)
-  (define-key js2-refactor-mode-map (funcall key-fn "dt") #'js2r-debug-this)
-  (define-key js2-refactor-mode-map (funcall key-fn "sl") #'js2r-forward-slurp)
-  (define-key js2-refactor-mode-map (funcall key-fn "ba") #'js2r-forward-barf)
-  (define-key js2-refactor-mode-map (funcall key-fn "k") #'js2r-kill)
-  (define-key js2-refactor-mode-map (kbd "<C-S-down>") #'js2r-move-line-down)
-  (define-key js2-refactor-mode-map (kbd "<C-S-up>") #'js2r-move-line-up))
-
-;;;###autoload
-(defun js2r-add-keybindings-with-prefix (prefix)
-  "Add js2r keybindings using the prefix PREFIX."
-  (setq js2-refactor-keybinding-prefix (read-kbd-macro prefix))
-  (js2r--add-keybindings (-partial #'js2r--key-pairs-with-prefix prefix)))
-
-;;;###autoload
-(defun js2r-add-keybindings-with-modifier (modifier)
-  "Add js2r keybindings using the modifier MODIFIER."
-  (js2r--add-keybindings (-partial #'js2r--key-pairs-with-modifier modifier)))
-
-(provide 'js2-refactor)
-;;; js2-refactor.el ends here
diff --git a/elpa/js2-refactor-20190630.2108/js2-refactor.elc b/elpa/js2-refactor-20190630.2108/js2-refactor.elc
deleted file mode 100644
index 9b3f645f..00000000
Binary files a/elpa/js2-refactor-20190630.2108/js2-refactor.elc and /dev/null differ
diff --git a/elpa/js2-refactor-20190630.2108/js2r-conditionals.el b/elpa/js2-refactor-20190630.2108/js2r-conditionals.el
deleted file mode 100644
index cd984eb0..00000000
--- a/elpa/js2-refactor-20190630.2108/js2r-conditionals.el
+++ /dev/null
@@ -1,57 +0,0 @@
-;;; js2r-conditionals.el --- Conditional refactoring functions for js2-refactor    -*- lexical-binding: t; -*-
-
-;; Copyright (C) 2012-2014 Magnar Sveen
-;; Copyright (C) 2015-2016 Magnar Sveen and Nicolas Petton
-
-;; Author: Magnar Sveen <magnars@gmail.com>,
-;;         Nicolas Petton <nicolas@petton.fr>
-;; Keywords: conveniences
-
-;; 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/>.
-
-;;; Code:
-
-(require 's)
-
-(require 'js2r-helpers)
-
-(defun js2r-ternary-to-if ()
-  "Convert a ternary operator to an if-statement."
-  (interactive)
-  (js2r--guard)
-  (js2r--wait-for-parse
-   (save-excursion
-     (let* ((ternary (js2r--closest 'js2-cond-node-p))
-	    (test-expr (js2-node-string (js2-cond-node-test-expr ternary)))
-	    (true-expr (js2-node-string (js2-cond-node-true-expr ternary)))
-	    (false-expr (js2-node-string (js2-cond-node-false-expr ternary)))
-	    (stmt (js2-node-parent-stmt ternary))
-	    (stmt-pre (buffer-substring (js2-node-abs-pos stmt) (js2-node-abs-pos ternary)))
-	    (stmt-post (s-trim (buffer-substring (js2-node-abs-end ternary) (js2-node-abs-end stmt))))
-	    (beg (js2-node-abs-pos stmt)))
-       (goto-char beg)
-       (delete-char (js2-node-len stmt))
-       (insert "if (" test-expr ") {")
-       (newline)
-       (insert stmt-pre true-expr stmt-post)
-       (newline)
-       (insert "} else {")
-       (newline)
-       (insert stmt-pre false-expr stmt-post)
-       (newline)
-       (insert "}")
-       (indent-region beg (point))))))
-
-(provide 'js2r-conditionals)
-;;; js2r-conditionals ends here
diff --git a/elpa/js2-refactor-20190630.2108/js2r-conditionals.elc b/elpa/js2-refactor-20190630.2108/js2r-conditionals.elc
deleted file mode 100644
index 8140c5eb..00000000
Binary files a/elpa/js2-refactor-20190630.2108/js2r-conditionals.elc and /dev/null differ
diff --git a/elpa/js2-refactor-20190630.2108/js2r-conveniences.el b/elpa/js2-refactor-20190630.2108/js2r-conveniences.el
deleted file mode 100644
index e5fa3dac..00000000
--- a/elpa/js2-refactor-20190630.2108/js2r-conveniences.el
+++ /dev/null
@@ -1,242 +0,0 @@
-;;; js2r-conveniences.el --- Convenience functions for js2-refactor    -*- lexical-binding: t; -*-
-
-;; Copyright (C) 2012-2014 Magnar Sveen
-;; Copyright (C) 2015-2016 Magnar Sveen and Nicolas Petton
-
-;; Author: Magnar Sveen <magnars@gmail.com>,
-;;         Nicolas Petton <nicolas@petton.fr>
-;; Keywords: conveniences
-
-;; 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:
-
-;; Convenience functions for logging statements by inserting
-;; `console.log' statements and moving lines respecting object
-;; literal syntax.
-
-;;; Code:
-
-(require 'js2r-helpers)
-
-(defun js2r-log-this (arg)
-  "Log of the node at point, adding a 'console.log()' statement.
-With a prefix argument ARG, use JSON pretty-printing for logging."
-  (interactive "P")
-  (js2r--guard)
-  (js2r--wait-for-parse
-   (let* ((log-info (js2r--figure-out-what-to-log-where))
-	  (stmt (car log-info))
-	  (pos (cdr log-info)))
-     (save-excursion
-       (goto-char pos)
-       (when (looking-at "[;{]")
-	 (forward-char 1))
-       (newline-and-indent)
-       (if arg
-	   (progn (insert "console.log(\"" stmt " = \");")
-		  (newline-and-indent)
-		  (insert "console.dir(" stmt ", { depth:null, colors: true });"))
-	 (insert "console.log(\"" stmt " = \", " stmt ");"))))))
-
-(defun js2r-debug-this ()
-  "Debug the node at point, adding a 'debug()' statement."
-  (interactive)
-  (js2r--guard)
-  (js2r--wait-for-parse
-   (let* ((log-info (js2r--figure-out-what-to-log-where))
-	  (stmt (car log-info))
-	  (pos (cdr log-info)))
-     (save-excursion
-       (goto-char pos)
-       (when (looking-at "[;{]")
-	 (forward-char 1))
-       (newline-and-indent)
-       (insert "debug(" (js2r--wrap-text stmt " = %s") ", " stmt ");")))))
-
-(defun js2r--figure-out-what-to-log-where ()
-  "Return a dotted pair containing the statement to log and the
-position where the log should be inserted."
-  (let ((parent-stmt (js2-node-parent-stmt (js2-node-at-point))))
-
-    (if (use-region-p)
-        (cons (buffer-substring (region-beginning) (region-end))
-              (js2r--find-suitable-log-position-around parent-stmt))
-
-      (let* ((node (js2r--name-node-at-point))
-             (parent (js2-node-parent node)))
-
-        (cond
-
-         ((js2-function-node-p parent)
-          (cons (js2-name-node-name node)
-                (js2-node-abs-pos (js2-function-node-body parent))))
-
-         ((js2-prop-get-node-p parent)
-          (cons (buffer-substring (js2-node-abs-pos parent) (js2-node-abs-end parent))
-                (js2r--find-suitable-log-position-around parent-stmt)))
-
-         (:else
-          (cons (js2-name-node-name node)
-                (js2r--find-suitable-log-position-around parent-stmt))))))))
-
-(defun js2r--find-suitable-log-position-around (parent-stmt)
-  "Return the position close to PARENT-STMT where the log statement should be inserted."
-  (if (or js2r-log-before-point (js2-return-node-p parent-stmt))
-      (save-excursion
-        (goto-char (js2-node-abs-pos parent-stmt))
-        (skip-chars-backward " \t\n\r") ; Can't use skip-syntax-backward since \n is end-comment
-        (point))
-    (js2-node-abs-end parent-stmt)))
-
-(defun js2r-split-string ()
-  "Split the string node at point.  If the string is already split, join it instead."
-  (interactive)
-  (when (js2r--point-inside-string-p)
-    (let ((delimiter (js2r--string-delimiter (js2-node-at-point))))
-     (if (looking-back " \"")
-         (progn
-           (forward-char -2)
-           (insert "  +")
-           (forward-char -2))
-       (if (looking-at (regexp-quote (format "%s + %s" delimiter delimiter)))
-           (delete-char 5)
-         (insert (format "%s + %s" delimiter delimiter)))))))
-
-(defun js2r-string-to-template ()
-  "Convert the string at point into a template string."
-  (interactive)
-  (let ((node (js2-node-at-point)))
-    (when (js2-string-node-p node)
-      (let* ((start (js2-node-abs-pos node))
-             (end (+ start (js2-node-len node))))
-        (when (memq (char-after start) '(?' ?\"))
-          (save-excursion
-            (goto-char end) (delete-char -1) (insert "`")
-            (goto-char start) (delete-char 1) (insert "`")
-            (perform-replace "`" "\\`" nil nil nil nil nil (1+ start) (1- end))))))))
-
-(defun js2r--string-delimiter (node)
-  "Return the delimiter character of the string node NODE.
-It can be a single or double quote."
-  (save-excursion
-    (goto-char (js2-node-abs-pos node))
-    (char-to-string (following-char))))
-
-(defun move-line-down ()
-  "Move the current line down one line."
-  (interactive)
-  (let ((col (current-column)))
-    (save-excursion
-      (forward-line)
-      (transpose-lines 1))
-    (forward-line)
-    (move-to-column col)))
-
-(defun move-line-up ()
-  "Move the current line up one line."
-  (interactive)
-  (let ((col (current-column)))
-    (transpose-lines 1)
-    (forward-line -2)
-    (move-to-column col)))
-
-(defun js2r-move-line-down ()
-  "Move the current line down one line.
-Make sure commas are placed correctly when moving a line up or
-down in an object or array literal."
-  (interactive)
-  (if (and (js2r--current-line-is-a-list-item)
-           (js2r--next-line-is-a-list-item))
-      (js2r--move-line-down-as-list-item)
-    (move-line-down))
-  (funcall indent-line-function))
-
-(defun js2r-move-line-up ()
-  "Move the current line up one line.
-Make sure commas are placed correctly when moving a line up or
-down in an object or array literal."
-  (interactive)
-  (if (and (js2r--current-line-is-a-list-item)
-           (js2r--previous-line-is-a-list-item))
-      (js2r--move-line-up-as-list-item)
-    (move-line-up))
-  (funcall indent-line-function))
-
-(defun js2r--current-line-is-prefixed-with-list-item-start ()
-  "Return whether the current line is prefixed with '{' or '['."
-  (save-excursion
-    (back-to-indentation)
-    (looking-back "\\({\\|\\[\\|,\\)\\(\s\\|\n\\|\t\\)*")))
-
-(defun js2r--current-line-is-postfixed-with-list-item-end ()
-  "Return whether the current line is postfixed with '{' or '['."
-  (save-excursion
-    (end-of-line)
-    (or (looking-back ",\s*") ; line ends in comma
-        (looking-at "\\(\s\\|\n\\|\t\\)*\\(\\]\\|}\\)"))))
-
-(defun js2r--current-line-is-a-list-item ()
-  "Return whether the current line contain an array or object literal."
-  (and (js2r--current-line-is-prefixed-with-list-item-start)
-       (js2r--current-line-is-postfixed-with-list-item-end)))
-
-(defun js2r--next-line-is-a-list-item ()
-  "Return whether the current line contain an array or object literal."
-  (save-excursion
-    (forward-line)
-    (js2r--current-line-is-a-list-item)))
-
-(defun js2r--previous-line-is-a-list-item ()
-  "Return whether the previous line contain an array or object literal, and only that."
-  (save-excursion
-    (forward-line -1)
-    (js2r--current-line-is-a-list-item)))
-
-(defun js2r--current-line-has-comma ()
-  "Return whether the current line ends with a comma."
-  (save-excursion
-    (end-of-line)
-    (looking-back ",\s*")))
-
-(defun js2r--previous-line-has-comma ()
-  "Return whether the previous line ends with a comma."
-  (save-excursion
-    (forward-line -1)
-    (js2r--current-line-has-comma)))
-
-(defun js2r--move-line-down-as-list-item ()
-  "Move the current line containing a list literal down one line, and also move the comma."
-  (move-line-down)
-  (if (not (js2r--previous-line-has-comma))
-      (save-excursion
-        (end-of-line)
-        (delete-char -1)
-        (forward-line -1)
-        (end-of-line)
-        (insert ","))))
-
-(defun js2r--move-line-up-as-list-item ()
-  "Move the current line containing a list literal up one line, and also move the comma."
-  (move-line-up)
-  (if (not (js2r--current-line-has-comma))
-      (save-excursion
-        (end-of-line)
-        (insert ",")
-        (forward-line)
-        (end-of-line)
-        (delete-char -1))))
-
-(provide 'js2r-conveniences)
-;;; js2r-conveniences.el ends here
diff --git a/elpa/js2-refactor-20190630.2108/js2r-conveniences.elc b/elpa/js2-refactor-20190630.2108/js2r-conveniences.elc
deleted file mode 100644
index 0c9b0e6c..00000000
Binary files a/elpa/js2-refactor-20190630.2108/js2r-conveniences.elc and /dev/null differ
diff --git a/elpa/js2-refactor-20190630.2108/js2r-formatting.el b/elpa/js2-refactor-20190630.2108/js2r-formatting.el
deleted file mode 100644
index a9137c36..00000000
--- a/elpa/js2-refactor-20190630.2108/js2r-formatting.el
+++ /dev/null
@@ -1,251 +0,0 @@
-;;; js2r-formatting.el --- Private helper functions for formatting    -*- lexical-binding: t; -*-
-
-;; Copyright (C) 2012-2014 Magnar Sveen
-;; Copyright (C) 2015-2016 Magnar Sveen and Nicolas Petton
-
-;; Author: Magnar Sveen <magnars@gmail.com>,
-;;         Nicolas Petton <nicolas@petton.fr>
-;; Keywords: conveniences
-
-;; 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/>.
-
-;;; Code:
-
-
-(defun js2r--ensure-newline ()
-  (if (and (not (looking-at "\s*\n"))
-           (not (looking-back "\n\s*")))
-      (newline-and-indent)))
-
-(defun js2r--ensure-just-one-space ()
-  (interactive)
-  (while (or (looking-at "\s*\n")
-             (looking-back "\n\s*"))
-    (when (looking-at "\n")
-      (delete-char 1))
-    (when (looking-back "\n\s")
-      (backward-char)
-      (delete-char -1))
-    (just-one-space))
-  (just-one-space))
-
-(defmacro js2r--create-bracketed-whitespace-traverser
-  (name ws-fix-func looking-at-start-func
-	goto-closest-start-func subexpr-str)
-  "Build a function to expand or contract a given type of
-   bracketed expression, i.e., function body, object literal, or
-   array (any of which may be nested).
-   Parameters:
-       name:                    name of the function to be built
-       ws-fix-func:             function to adjust whitespace at point
-       looking-at-start-func:   returns t if point is at
-                                    the start of the bracketed
-                                    thing we want to act on
-       goto-closest-start-func: moves point if necessary
-                                    until looking-at-start-func
-                                    is true
-       subexpr-str:             literal delimiter of parts of the
-                                    thing to be expanded or contracted"
-  `(defun ,name ()
-     (interactive)
-     (save-excursion
-       (if (not ,looking-at-start-func)
-           ,goto-closest-start-func)
-       (let ((end (make-marker)))
-         (set-marker end (save-excursion
-                           (forward-list)
-                           (point)))
-         (forward-char)
-         ,ws-fix-func
-         (while (< (point) end)
-           (while (js2r--point-inside-string-p)
-             (forward-char))
-           (when (looking-at ,subexpr-str)
-             (forward-char)
-             (unless (js2-comment-node-p (js2-node-at-point))
-              ,ws-fix-func))
-           (if (looking-at "\\s(")
-               (forward-list)
-             (forward-char)))
-         (backward-char)
-         ,ws-fix-func))))
-
-(defun js2r--looking-at-object-start ()
-  (and (looking-at "{")
-       (not (looking-back ")[\s\n]*"))))
-
-(defun js2r--goto-closest-object-start ()
-  (while (not (js2r--looking-at-object-start))
-    (if (eq (car (syntax-ppss)) 0)
-        (error "Cursor is not on an object")
-      (goto-char (nth 1 (syntax-ppss))))))
-
-(js2r--create-bracketed-whitespace-traverser js2r-expand-object
-					     (js2r--ensure-newline)
-					     (js2r--looking-at-object-start)
-					     (js2r--goto-closest-object-start)
-					     ",")
-
-(js2r--create-bracketed-whitespace-traverser js2r-contract-object
-					     (js2r--ensure-just-one-space)
-					     (js2r--looking-at-object-start)
-					     (js2r--goto-closest-object-start)
-					     ",")
-
-(defun js2r--looking-at-array-start ()
-  (looking-at "\\["))
-
-(defun js2r--goto-closest-array-start ()
-  (while (not (js2r--looking-at-array-start))
-    (if (eq (car (syntax-ppss)) 0)
-        (error "Cursor is not on an array")
-      (goto-char (nth 1 (syntax-ppss))))))
-
-(js2r--create-bracketed-whitespace-traverser js2r-expand-array
-					     (js2r--ensure-newline)
-					     (js2r--looking-at-array-start)
-					     (js2r--goto-closest-array-start)
-					     ",")
-
-(js2r--create-bracketed-whitespace-traverser js2r-contract-array
-					     (js2r--ensure-just-one-space)
-					     (js2r--looking-at-array-start)
-					     (js2r--goto-closest-array-start)
-					     ",")
-
-;; (defun js2r--looking-at-function-start ()
-;;   (or
-;;    (and (looking-at "{")
-;;         (looking-back
-;;          ;; This horrible-looking regexp is actually pretty simple.  It
-;;          ;; matches "function <optional_name> (<optional_parameters,...>)"
-;;          ;; allowing for whitespace.  TODO: support Unicode in function and
-;;          ;; parameter names.
-;;          (concat "function[\s\n]*"
-;;                  "\\\([a-zA-Z_$][a-zA-Z_$0-9]*[\s\n]*\\\)?"
-;;                  "\(\\\([a-zA-Z_$][a-zA-Z_$0-9]*"
-;;                  "[\s\n]*,[\s\n]*\\\)*[\s\n]*"
-;;                  "\\\([a-zA-Z_$][a-zA-Z_$0-9]*[\s\n]*\\\)*"
-;;                  "[\s\n]*\)[\s\n]*")))
-;;    ;; arrow functions
-;;    (and (looking-at "{")
-;;         (looking-back "=>[\s\n]*")
-;;         (not (js2r--point-inside-string-p)))))
-
-(defun js2r--looking-at-function-start ()
-  "Return non-nil if the point is at the start of a function body."
-  (let* ((node (js2-node-at-point))
-	 (parent (js2-node-parent node)))
-    (and (looking-at "{")
-	 (js2-block-node-p node)
-	 (js2-function-node-p parent))))
-
-(defun js2r--goto-closest-function-start ()
-  (while (not (js2r--looking-at-function-start))
-    (if (eq (car (syntax-ppss)) 0)
-        (error "Cursor is not on a function body")
-      (goto-char (nth 1 (syntax-ppss))))))
-
-(js2r--create-bracketed-whitespace-traverser js2r-expand-function
-					     (js2r--ensure-newline)
-					     (js2r--looking-at-function-start)
-					     (js2r--goto-closest-function-start)
-					     ";")
-
-;; TODO: It'd be great if js2r-contract-function could recognize
-;; newlines that are implied statement terminators and insert
-;; semicolons correctly, but that would probably mean not using the
-;; same macro as the other "contract" function definitions.
-(js2r--create-bracketed-whitespace-traverser js2r-contract-function
-					     (js2r--ensure-just-one-space)
-					     (js2r--looking-at-function-start)
-					     (js2r--goto-closest-function-start)
-					     ";")
-
-(defun js2r--looking-at-call-start ()
-  (looking-at "("))
-
-(defun js2r--goto-closest-call-start ()
-  (while (not (js2r--looking-at-call-start))
-    (if (eq (car (syntax-ppss)) 0)
-        (error "Cursor is not on a call")
-      (goto-char (nth 1 (syntax-ppss))))))
-
-(js2r--create-bracketed-whitespace-traverser js2r-expand-call-args
-               (js2r--ensure-newline)
-               (js2r--looking-at-call-start)
-               (js2r--goto-closest-call-start)
-               ",")
-
-(js2r--create-bracketed-whitespace-traverser js2r-contract-call-args
-               (js2r--ensure-just-one-space)
-               (js2r--looking-at-call-start)
-               (js2r--goto-closest-call-start)
-               ",")
-
-(defun js2r--expand-contract-node-at-point (&optional is-contract)
-  "Expand or contract bracketed list according to node type in point.
-Currently working on array, object, function and call args node types.
-With argument, contract closest expression, otherwise expand."
-  (let ((pos (point))
-        (array-start (point-max))
-        (object-start (point-max))
-        (function-start (point-max))
-        (call-start (point-max)))
-    (save-excursion
-      (ignore-errors
-        (js2r--goto-closest-array-start)
-        (setq array-start (- pos (point)))))
-    (save-excursion
-      (ignore-errors
-        (js2r--goto-closest-object-start)
-        (setq object-start (- pos (point)))))
-    (save-excursion
-      (ignore-errors
-        (js2r--goto-closest-function-start)
-        (setq function-start (- pos (point)))))
-    (save-excursion
-      (ignore-errors
-        (js2r--goto-closest-call-start)
-        (setq call-start (- pos (point)))))
-    (setq pos (-min (list array-start object-start function-start call-start)))
-    (when (= pos array-start)
-      (if is-contract
-          (js2r-contract-array)
-        (js2r-expand-array)))
-    (when (= pos object-start)
-      (if is-contract
-          (js2r-contract-object)
-        (js2r-expand-object)))
-    (when (= pos function-start)
-      (if is-contract
-          (js2r-contract-function)
-        (js2r-expand-function)))
-    (when (= pos call-start)
-      (if is-contract
-          (js2r-contract-call-args)
-        (js2r-expand-call-args)))))
-
-(defun js2r-expand-node-at-point ()
-  "Expand bracketed list according to node type at point."
-  (interactive)
-  (js2r--expand-contract-node-at-point))
-
-(defun js2r-contract-node-at-point ()
-  "Contract bracketed list according to node type at point."
-  (interactive)
-  (js2r--expand-contract-node-at-point t))
-
-(provide 'js2r-formatting)
-;;; js2-formatting.el ends here
diff --git a/elpa/js2-refactor-20190630.2108/js2r-formatting.elc b/elpa/js2-refactor-20190630.2108/js2r-formatting.elc
deleted file mode 100644
index c40ebd3f..00000000
Binary files a/elpa/js2-refactor-20190630.2108/js2r-formatting.elc and /dev/null differ
diff --git a/elpa/js2-refactor-20190630.2108/js2r-functions.el b/elpa/js2-refactor-20190630.2108/js2r-functions.el
deleted file mode 100644
index 31e331ae..00000000
--- a/elpa/js2-refactor-20190630.2108/js2r-functions.el
+++ /dev/null
@@ -1,537 +0,0 @@
-;;; js2r-functions.el --- Function manipulation functions for js2-refactor    -*- lexical-binding: t; -*-
-
-;; Copyright (C) 2012-2014 Magnar Sveen
-;; Copyright (C) 2015-2016 Magnar Sveen and Nicolas Petton
-
-;; Author: Magnar Sveen <magnars@gmail.com>,
-;;         Nicolas Petton <nicolas@petton.fr>
-;; Keywords: conveniences
-
-;; 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/>.
-
-;;; Code:
-
-(require 'dash)
-(require 'yasnippet)
-
-(require 'js2r-helpers)
-
-(defun js2r-localize-parameter ()
-  "Turn parameter into local var in local function."
-  (interactive)
-  (js2r--guard)
-  (js2r--wait-for-parse
-   (if (js2-name-node-p (js2-node-at-point))
-       (js2r--localize-parameter-pull)
-     (js2r--localize-parameter-push))))
-
-(defun js2r--localize-parameter-push ()
-  (let* ((node (js2-node-at-point))
-         (arg-node (or (js2r--closest-node-where 'js2r--parent-is-call-node node)
-                       (error "Place cursor on argument to localize")))
-         (call-node (js2-node-parent arg-node))
-         (value (js2-node-string arg-node))
-         (target (js2-call-node-target call-node))
-         (fn (if (js2-name-node-p target)
-                 (js2r--local-fn-from-name-node target)
-               (error "Can only localize parameter for local functions")))
-         (usages (js2r--function-usages fn))
-         (index (car (--keep (when (eq arg-node it) it-index)
-                             (js2-call-node-args call-node))))
-         (name (js2-name-node-name (nth index (js2-function-node-params fn)))))
-    (js2r--localize-parameter fn usages index name value)))
-
-(defun js2r--localize-parameter-pull ()
-  (let* ((name-node (js2-node-at-point))
-         (name (if (js2-name-node-p name-node)
-                   (js2-name-node-name name-node)
-                 (error "Place cursor on parameter to localize")))
-         (fn (or (js2r--closest-node-where #'js2r--is-local-function name-node)
-                 (error "Can only localize parameter in local functions")))
-         (index (or (js2r--param-index-for name fn)
-                    (error "%S isn't a parameter to this function" name)))
-         (usages (js2r--function-usages fn))
-         (examples (-distinct (--map (js2r--argument index it) usages)))
-         (value (js2r--choose-one "Value: " examples)))
-    (js2r--localize-parameter fn usages index name value)))
-
-(defun js2r--localize-parameter (fn usages index name value)
-  (save-excursion
-    (js2r--goto-fn-body-beg fn)
-    (save-excursion
-      (--each usages (js2r--remove-argument-at-index index it)))
-    (newline-and-indent)
-    (insert "var " name " = " value ";")
-    (js2r--remove-parameter-at-index index fn)))
-
-(defun js2r--parent-is-call-node (node)
-  (js2-call-node-p (js2-node-parent node)))
-
-(defun js2r--local-fn-from-name-node (name-node)
-  (->> name-node
-    (js2r--local-usages-of-name-node)
-    (-map #'js2-node-parent)
-    (-first #'js2-function-node-p)))
-
-(defun js2r--param-index-for (name fn)
-  (car (--keep (when (equal name (js2-name-node-name it)) it-index)
-               (js2-function-node-params fn))))
-
-(defun js2r--argument (index call-node)
-  (js2-node-string (nth index (js2-call-node-args call-node))))
-
-(defun js2r--remove-parameter-at-index (index fn)
-  (js2r--delete-node-in-params (nth index (js2-function-node-params fn))))
-
-(defun js2r--remove-argument-at-index (index call-node)
-  (js2r--delete-node-in-params (nth index (js2-call-node-args call-node))))
-
-(defun js2r--delete-node-in-params (node)
-  (goto-char (js2-node-abs-pos node))
-  (delete-char (js2-node-len node))
-  (if (and (looking-back "(")
-           (looking-at ", "))
-      (delete-char 2)
-    (when (looking-back ", ")
-      (delete-char -2))))
-
-(defun js2r--choose-one (prompt options)
-  (when options
-    (if (cdr options)
-        (completing-read prompt options)
-      (car options))))
-
-(defun js2r-introduce-parameter ()
-  "Introduce a parameter in a local function."
-  (interactive)
-  (js2r--guard)
-  (js2r--wait-for-parse
-   (if (use-region-p)
-       (js2r--introduce-parameter-between (region-beginning) (region-end))
-     (let ((node (js2r--closest-extractable-node)))
-       (js2r--introduce-parameter-between (js2-node-abs-pos node)
-					  (js2-node-abs-end node))))))
-
-(defun js2r--introduce-parameter-between (beg end)
-  (unless (js2r--single-complete-expression-between-p beg end)
-    (error "Can only introduce single, complete expressions as parameter"))
-
-  (let ((fn (js2r--closest-node-where #'js2r--is-local-function (js2-node-at-point))))
-    (unless fn
-      (error "Can only introduce parameter in local functions"))
-    (save-excursion
-      (let ((name (read-string "Parameter name: "))
-            (val (buffer-substring beg end))
-            (usages (js2r--function-usages fn)))
-        (goto-char beg)
-        (save-excursion
-          (-each usages (-partial #'js2r--add-parameter val)))
-        (delete-char (- end beg))
-        (insert name)
-        (js2r--add-parameter name fn)
-        (query-replace val name nil (js2-node-abs-pos fn) (js2r--fn-body-end fn))))))
-
-(defun js2r--function-usages (fn)
-  (-map #'js2-node-parent (js2r--function-usages-name-nodes fn)))
-
-(defun js2r--function-usages-name-nodes (fn)
-  (let ((name-node (or (js2-function-node-name fn)
-                       (js2-var-init-node-target (js2-node-parent fn)))))
-    (remove name-node (js2r--local-usages-of-name-node name-node))))
-
-(defun js2r--add-parameter (name node)
-  (save-excursion
-    (js2r--goto-closing-paren node)
-    (unless (looking-back "(")
-      (insert ", "))
-    (insert name)))
-
-(defun js2r--goto-closing-paren (node)
-  (goto-char (js2-node-abs-pos node))
-  (search-forward "(")
-  (forward-char -1)
-  (forward-list)
-  (forward-char -1))
-
-(defun js2r--goto-fn-body-beg (fn)
-  (goto-char (js2-node-abs-pos fn))
-  (search-forward "{"))
-
-(defun js2r--fn-body-end (fn)
-  (save-excursion
-    (js2r--goto-fn-body-beg fn)
-    (forward-char -1)
-    (forward-list)
-    (point)))
-
-(defun js2r--is-local-function (node)
-  (or (js2r--is-var-function-expression node)
-      (js2r--is-function-declaration node)))
-
-(defun js2r--is-method (node)
-  (and (js2-function-node-p node)
-       (js2-object-prop-node-p (js2-node-parent node))))
-
-(defun js2r--is-var-function-expression (node)
-  (and (js2-function-node-p node)
-       (js2-var-init-node-p (js2-node-parent node))))
-
-(defun js2r--is-assigned-function-expression (node)
-  (and (js2-function-node-p node)
-       (js2-assign-node-p (js2-node-parent node))))
-
-(defun js2r--is-function-declaration (node)
-  (let ((parent (js2-node-parent node)))
-    (and (js2-function-node-p node)
-         (not (js2-assign-node-p parent))
-         (not (js2-var-init-node-p parent))
-         (not (js2-object-prop-node-p parent)))))
-
-(defun js2r-arguments-to-object ()
-  "Change from a list of arguments to a parameter object."
-  (interactive)
-  (js2r--guard)
-  (js2r--wait-for-parse
-   (let ((node (js2-node-at-point)))
-     (unless (and (looking-at "(")
-		  (or (js2-function-node-p node)
-		      (js2-call-node-p node)
-		      (js2-new-node-p node)))
-       (error "Place point right before the opening paren in the call or function"))
-
-     (-when-let* ((target (js2r--node-target node))
-		  (fn (and (js2-name-node-p target)
-			   (js2r--local-fn-from-name-node target))))
-       (setq node fn))
-     (if (js2-function-node-p node)
-	 (js2r--arguments-to-object-for-function node)
-       (js2r--arguments-to-object-for-args-with-unknown-function (js2r--node-args node))))))
-
-(defun js2r--arguments-to-object-for-function (function-node)
-  (let ((params (js2-function-node-params function-node)))
-    (when (null params)
-      (error "No params to convert"))
-    (save-excursion
-      (js2r--execute-changes
-       (-concat
-        ;; change parameter list to just (params)
-        (list
-         (list :beg (+ (js2-node-abs-pos function-node) (js2-function-node-lp function-node))
-               :end (+ (js2-node-abs-pos function-node) (js2-function-node-rp function-node) 1)
-               :contents "(params)"))
-
-        ;; add params. in front of function local param usages
-        (let* ((local-param-name-nodes (--mapcat (-> it
-                                                   (js2-node-abs-pos)
-                                                   (js2r--local-name-node-at-point)
-                                                   (js2r--local-usages-of-name-node))
-                                                 params))
-               (local-param-name-usages (--remove (js2-function-node-p (js2-node-parent it))
-                                                  local-param-name-nodes))
-               (local-param-name-positions (-map #'js2-node-abs-pos local-param-name-usages)))
-          (--map
-           (list :beg it :end it :contents "params.")
-           local-param-name-positions))
-
-        ;; update usages of function
-        (let ((names (-map #'js2-name-node-name params))
-              (usages (js2r--function-usages function-node)))
-          (--map
-           (js2r--changes/arguments-to-object it names)
-           usages)))))))
-
-(defun js2r--changes/arguments-to-object (node names)
-  (let ((args (js2r--node-args node)))
-    (list :beg (+ (js2-node-abs-pos node) (js2r--node-lp node))
-          :end (+ (js2-node-abs-pos node) (js2r--node-rp node) 1)
-          :contents (js2r--create-object-with-arguments names args))))
-
-(defun js2r--arguments-to-object-for-args-with-unknown-function (args)
-  (when (null args)
-    (error "No arguments to convert"))
-  (let ((names (--map-indexed
-                (format "${%d:%s}"
-                        (1+ it-index)
-                        (if (js2-name-node-p it)
-                            (js2-name-node-name it)
-                          "key"))
-                args)))
-    (yas-expand-snippet (js2r--create-object-with-arguments names args)
-                        (point)
-                        (save-excursion (forward-list) (point)))))
-
-(defun js2r--create-object-with-arguments (names args)
-  (let (arg key result)
-    (--dotimes (length args)
-      (setq arg (nth it args))
-      (setq key (nth it names))
-      (setq result
-            (concat result
-                    (format "    %s: %s,\n"
-                            key
-                            (buffer-substring (js2-node-abs-pos arg)
-                                              (js2-node-abs-end arg))))))
-    (concat "({\n" (substring result 0 -2) "\n})")))
-
-(defun js2r-extract-function (name)
-  "Extract a function from the closest statement expression from the point."
-  (interactive "sName of new function: ")
-  (js2r--extract-fn
-   name
-   (lambda ()
-       (unless (js2r--looking-at-function-declaration)
-         (goto-char (js2-node-abs-pos (js2r--closest #'js2-expr-stmt-node-p)))))
-   "%s(%s);"
-   "function %s(%s) {\n%s\n}\n\n"))
-
-(defun js2r-extract-method (name)
-  "Extract a method from the closest statement expression from the point."
-  (interactive "sName of new method: ")
-  (let ((class-node (js2r--closest #'js2-class-node-p)))
-    (js2r--extract-fn
-     name
-     (unless class-node
-       (lambda ()
-         (goto-char (js2-node-abs-pos (js2r--closest #'js2-object-prop-node-p)))))
-     "this.%s(%s);"
-     (if class-node
-         "%s(%s) {\n%s\n}\n\n"
-       "%s: function (%s) {\n%s\n},\n\n"))))
-
-(defun js2r--extract-fn (name goto-position call-template function-template)
-  (js2r--guard)
-  (js2r--wait-for-parse
-   (unless (use-region-p)
-     (error "Mark the expressions to extract first"))
-   (save-excursion
-     (let* ((parent (js2r--first-common-ancestor-in-region (region-beginning) (region-end)))
-	    (block (js2r--closest-node-where #'js2-block-node-p parent))
-	    (fn (js2r--closest-node-where #'js2-function-node-p block))
-	    (exprs (js2r--marked-expressions-in-block block))
-	    (vars (-mapcat #'js2r--name-node-decendants exprs))
-	    (local (--filter (js2r--local-to-fn-p fn it) vars))
-	    (names (-distinct (-map 'js2-name-node-name local)))
-	    (declared-in-exprs (-map #'js2r--var-init-node-target-name (-mapcat #'js2r--var-init-node-decendants exprs)))
-	    (outside-exprs (-difference (js2-block-node-kids block) exprs))
-	    (outside-var-uses (-map #'js2-name-node-name (-mapcat #'js2r--name-node-decendants outside-exprs)))
-	    (declared-in-but-used-outside (-intersection declared-in-exprs outside-var-uses))
-	    (export-var (car declared-in-but-used-outside))
-	    (params (-difference names declared-in-exprs))
-	    (params-string (mapconcat #'identity (reverse params) ", "))
-	    (first (car exprs))
-	    (last (car (last exprs)))
-	    (beg (js2-node-abs-pos (car exprs)))
-	    (end (js2-node-abs-end last))
-	    (contents (buffer-substring beg end)))
-       (goto-char beg)
-       (delete-region beg end)
-       (when (js2-return-node-p last)
-	 (insert "return "))
-       (when export-var
-	 (setq contents (concat contents "\nreturn " export-var ";"))
-	 (insert "var " export-var " = "))
-       (insert (format call-template name params-string))
-       (goto-char (js2-node-abs-pos fn))
-       (when goto-position (funcall goto-position))
-       (let ((start (point)))
-	 (insert (format function-template name params-string contents))
-	 (indent-region start (1+ (point))))))))
-
-(defun js2r--var-init-node-target-name (node)
-  (js2-name-node-name
-   (js2-var-init-node-target node)))
-
-(defun js2r--function-around-region ()
-  (or
-   (js2r--closest-node-where #'js2-function-node-p
-                             (js2r--first-common-ancestor-in-region
-                              (region-beginning)
-                              (region-end)))
-   (error "This only works when you mark stuff inside a function")))
-
-(defun js2r--marked-expressions-in-block (fn)
-  (-select #'js2r--node-is-marked (js2-block-node-kids fn)))
-
-(defun js2r--node-is-marked (node)
-  (and
-   (<= (region-beginning) (js2-node-abs-end node))
-   (>= (region-end) (js2-node-abs-pos node))))
-
-(defun js2r--name-node-decendants (node)
-  (-select #'js2-name-node-p (js2r--decendants node)))
-
-(defun js2r--var-init-node-decendants (node)
-  (-select #'js2-var-init-node-p (js2r--decendants node)))
-
-(defun js2r--decendants (node)
-  (let (vars)
-    (js2-visit-ast node
-                   (lambda (node end-p)
-                      (unless end-p
-                        (setq vars (cons node vars)))))
-    vars))
-
-(defun js2r--local-to-fn-p (fn name-node)
-  (let* ((name (js2-name-node-name name-node))
-         (scope (js2-node-get-enclosing-scope name-node))
-         (scope (js2-get-defining-scope scope name)))
-    (eq fn scope)))
-
-
-(defun js2r-toggle-arrow-function-and-expression ()
-  "Toggle between function expression to arrow function."
-  (interactive)
-  (save-excursion
-    (js2r--find-closest-function)
-    (cond ((js2r--arrow-function-p)
-           (js2r--transform-arrow-function-to-expression))
-          ((and (js2r--function-start-p) (not (js2r--looking-at-function-declaration)))
-           (js2r--transform-function-expression-to-arrow))
-          (t (error "Can only toggle between function expressions and arrow function")))))
-
-
-;; Toggle between function name() {} and var name = function ();
-
-(defun js2r-toggle-function-expression-and-declaration ()
-  (interactive)
-  (save-excursion
-    (js2r--find-closest-function)
-    (cond
-     ((js2r--looking-at-var-function-expression)
-      (when (js2r--arrow-function-p) (js2r--transform-arrow-function-to-expression))
-      (js2r--transform-function-expression-to-declaration))
-     ((js2r--looking-at-function-declaration)
-      (js2r--transform-function-declaration-to-expression))
-     (t (error "Can only toggle between function declarations and free standing function expressions")))))
-
-
-(defun js2r--arrow-function-p ()
-  (interactive)
-  (save-excursion
-    (ignore-errors
-      (js2r--find-closest-function)
-      (and (looking-at "(?[,[:space:][:word:]]*)?[[:space:]]*=>")
-           (not (js2r--point-inside-string-p))))))
-
-(defun js2r--transform-arrow-function-to-expression ()
-  (when (js2r--arrow-function-p)
-    (let (has-parenthesis)
-      (save-excursion
-        (js2r--find-closest-function)
-        (let ((end (make-marker)))
-          (save-excursion
-            (search-forward "=>")
-            (set-marker end (js2-node-abs-end (js2-node-at-point))))
-          (setq has-parenthesis (looking-at "\\s-*("))
-          (insert "function ")
-          (if has-parenthesis
-              (forward-list)
-            (insert "("))
-          (search-forward "=>")
-          (delete-char -2)
-          (js2r--ensure-just-one-space)
-          (unless has-parenthesis
-            (backward-char 1)
-            (insert ")"))
-          (unless (looking-at "\\s-*{")
-            (js2r--ensure-just-one-space)
-            (insert "{ return ")
-            (js2r--ensure-just-one-space)
-            (goto-char (marker-position end))
-            (insert "; }")))))))
-
-(defun js2r--transform-function-expression-to-arrow ()
-  (when (not (js2r--arrow-function-p))
-    (save-excursion
-      (js2r--find-closest-function)
-      (let ((pos (point))
-             (params
-              (js2-function-node-params (js2-node-at-point)))
-             parenthesis-start
-             parenthesis-end)
-        (when (js2r--looking-at-function-declaration)
-          (error "Can not convert function declarations to arrow function"))
-        (search-forward "(")
-        (backward-char 1)
-        (delete-region pos (point))
-        (setq parenthesis-start (point))
-        (forward-list)
-        (setq parenthesis-end (point))
-        (insert " => ")
-        (js2r--ensure-just-one-space)
-        (when (and (= 1 (length params))
-                   (not js2r-always-insert-parens-around-arrow-function-params))
-          (goto-char parenthesis-end)
-          (backward-delete-char 1)
-          (goto-char parenthesis-start)
-          (delete-char 1))))))
-
-
-(defun js2r--function-start-p()
-  (let* ((fn (js2r--closest #'js2-function-node-p)))
-    (and fn
-    (= (js2-node-abs-pos fn) (point)))))
-
-(defun js2r--find-closest-function ()
-  (when (not (js2r--function-start-p))
-    (let* ((fn (js2r--closest #'js2-function-node-p)))
-      (goto-char (js2-node-abs-pos fn)))))
-
-(defun js2r--looking-at-method ()
-  (and (js2r--function-start-p)
-       (looking-back ": ?")))
-
-(defun js2r--looking-at-function-declaration ()
-  (and (js2r--function-start-p)
-       (looking-back "^ *")))
-
-(defun js2r--looking-at-var-function-expression ()
-  (and (js2r--function-start-p)
-       (looking-back "^ *var[\s\n]*[a-z_$]+[\s\n]*=[\s\n]*")))
-
-(defun js2r--transform-function-expression-to-declaration ()
-  (when (js2r--looking-at-var-function-expression)
-    (delete-char 9)
-    (forward-list)
-    (forward-list)
-    (delete-char 1)
-    (backward-list)
-    (backward-list)
-    (delete-backward-char 3)
-    (back-to-indentation)
-    (delete-char 4)
-    (insert "function ")))
-
-(defun js2r--transform-function-declaration-to-expression ()
-  (when (js2r--looking-at-function-declaration)
-    (delete-char 9)
-    (insert "var ")
-    (search-forward "(")
-    (backward-char 1)
-    (insert " = function ")
-    (forward-list)
-    (forward-list)
-    (insert ";")))
-
-(defun js2r-toggle-function-async ()
-  "Toggle the innermost function from sync to async."
-  (interactive)
-  (save-excursion
-    (js2r--find-closest-function)
-    (if (looking-back "async[[:space:]\n]+")
-        (delete-region (match-beginning 0) (match-end 0))
-      (insert "async "))))
-
-(provide 'js2r-functions)
-;;; js2-functions.el ends here
diff --git a/elpa/js2-refactor-20190630.2108/js2r-functions.elc b/elpa/js2-refactor-20190630.2108/js2r-functions.elc
deleted file mode 100644
index c4c1fc83..00000000
Binary files a/elpa/js2-refactor-20190630.2108/js2r-functions.elc and /dev/null differ
diff --git a/elpa/js2-refactor-20190630.2108/js2r-helpers.el b/elpa/js2-refactor-20190630.2108/js2r-helpers.el
deleted file mode 100644
index e0183d9d..00000000
--- a/elpa/js2-refactor-20190630.2108/js2r-helpers.el
+++ /dev/null
@@ -1,220 +0,0 @@
-;;; js2r-helpers.el --- Private helper functions for js2-refactor    -*- lexical-binding: t; -*-
-
-;; Copyright (C) 2012-2014 Magnar Sveen
-;; Copyright (C) 2015-2016 Magnar Sveen and Nicolas Petton
-
-;; Author: Magnar Sveen <magnars@gmail.com>,
-;;         Nicolas Petton <nicolas@petton.fr>
-;; Keywords: conveniences
-
-;; 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/>.
-
-;;; Code:
-
-(require 'dash)
-(require 's)
-(require 'js2-mode)
-
-(defmacro js2r--wait-for-parse (&rest body)
-  "Evaluate BODY once the current buffer has been parsed."
-  `(js2-mode-wait-for-parse (lambda () ,@body)))
-
-(defun js2r--wrap-text (&rest text)
-  "Wrap TEXT with the prefered quotes.  The prefered quotes is set with `js2r-prefered-quote-type'."
-  (let ((prefered-quotes "\""))
-    (when (= 2 js2r-prefered-quote-type)
-      (setq prefered-quotes "'"))
-    (concat prefered-quotes (apply 'concat text) prefered-quotes)))
-
-(defun js2r--fix-special-modifier-combinations (key)
-  (case key
-    ("C-s-i" "s-TAB")
-    ("C-s-m" "s-RET")
-    (otherwise key)))
-
-(defun js2r--key-pairs-with-modifier (modifier keys)
-  (->> (string-to-list keys)
-    (--map (js2r--fix-special-modifier-combinations
-            (concat modifier (char-to-string it))))
-    (s-join " ")
-    (read-kbd-macro)))
-
-(defun js2r--key-pairs-with-prefix (prefix keys)
-  (read-kbd-macro (concat prefix " " keys)))
-
-(defun js2r--guard ()
-  (when js2-parsed-errors
-    (error "Can't refactor while buffer has parse errors")))
-
-(defun js2r--current-quotes-char ()
-  "The char that is the current quote delimiter"
-  (nth 3 (syntax-ppss)))
-
-(defalias 'js2r--point-inside-string-p 'js2r--current-quotes-char)
-
-(defun js2r--closest-node-where (p node)
-  (if (or (null node)
-          (apply p node nil))
-      node
-    (js2r--closest-node-where p (js2-node-parent node))))
-
-(defun js2r--closest (p)
-  (save-excursion
-    (cond
-     ((bolp) (back-to-indentation))
-     ((looking-at ";") (forward-char -1))
-     ((looking-back ";") (forward-char -2))
-     ((looking-back "}") (forward-char -1)))
-    (js2r--closest-node-where p (js2-node-at-point))))
-
-(defun js2r--goto-and-delete-node (node)
-  (goto-char (js2-node-abs-pos node))
-  (delete-char (js2-node-len node)))
-
-
-(defun js2r--path-to-root (node)
-  (when node
-    (cons node (js2r--path-to-root (js2-node-parent node)))))
-
-(defun js2r--first-common-ancestor (node1 node2)
-  (if (eq node1 node2)
-      node1
-    (let ((path1 (reverse (js2r--path-to-root node1)))
-          (path2 (reverse (js2r--path-to-root node2)))
-          (last-common nil))
-      (while (eq (car path1) (car path2))
-        (setq last-common (car path1))
-        (setq path1 (cdr path1))
-        (setq path2 (cdr path2)))
-      last-common)))
-
-(defun js2r--first-common-ancestor-in-region (beg end)
-  (js2r--first-common-ancestor (js2-node-at-point beg)
-                               (js2-node-at-point end)))
-
-;; abstract away node type on some common property getters
-(defun js2r--node-target (node)
-  (cond
-   ((js2-call-node-p node) (js2-call-node-target node))
-   ((js2-new-node-p node) (js2-new-node-target node))
-   (:else nil)))
-
-(defun js2r--node-args (node)
-  (cond
-   ((js2-call-node-p node) (js2-call-node-args node))
-   ((js2-new-node-p node) (js2-new-node-args node))
-   (:else nil)))
-
-(defun js2r--node-lp (node)
-  (cond
-   ((js2-call-node-p node) (js2-call-node-lp node))
-   ((js2-new-node-p node) (js2-new-node-lp node))
-   (:else nil)))
-
-(defun js2r--node-rp (node)
-  (cond
-   ((js2-call-node-p node) (js2-call-node-rp node))
-   ((js2-new-node-p node) (js2-new-node-rp node))
-   (:else nil)))
-
-(defun js2r--node-kids (node)
-  (cond
-   ((js2-function-node-p node) (js2-block-node-kids (js2-function-node-body node)))
-   ((js2-if-node-p node) (js2-scope-kids (js2-if-node-then-part node)))
-   ((js2-for-node-p node) (js2-block-node-kids (js2-for-node-body node)))
-   ((js2-while-node-p node) (js2-block-node-kids (js2-while-node-body node)))))
-
-;; finding expressions and arguments
-
-(defun js2r--closest-extractable-node ()
-  "Return the most appropriate node the be extracted into a variable or paramter.
-Lookup the closest expression node from the point, or the closest literal node instead.
-If no node is found, signal an error."
-  (or (or (js2r--closest #'js2r--expression-p)
-          (js2r--closest #'js2r--literal-node-p))
-      (error "Cannot perform refactoring: Nothing to extract at point")))
-
-(defun js2r--closest-stmt-node ()
-  "Return the closest standalone statement node.
-Special care is taken for if branch nodes: if a statement node is
-part of an if branch node (like 'else if' nodes), return the
-parent node."
-  (let* ((node (js2-node-parent-stmt (js2-node-at-point)))
-        (parent (js2-node-parent node)))
-    (if (and (js2-if-node-p node)
-             (js2-if-node-p parent))
-        parent
-      node)))
-
-(defun js2r--argument-p (node)
-  (let ((parent (js2-node-parent node)))
-    (and (js2-call-node-p parent)
-         (member node (js2-call-node-args parent)))))
-
-(defun js2r--expression-p (node)
-  (or (js2-call-node-p node)
-      (js2r--argument-p node)
-      (and (js2-prop-get-node-p node)
-           (not (js2-call-node-p (js2-node-parent node))))))
-
-(defun js2r--literal-node-p (node)
-  (or (js2-object-node-p node)
-      (js2-string-node-p node)
-      (js2-number-node-p node)
-      (js2r--boolean-node-p node)))
-
-(defun js2r--boolean-node-p (node)
-  (let* ((beg (js2-node-abs-pos node))
-         (end (js2-node-abs-end node))
-         (content (buffer-substring beg end)))
-    (and (js2-keyword-node-p node)
-         (member content '("true" "false")))))
-
-(defun js2r--single-complete-expression-between-p (beg end)
-  (let ((ancestor (js2r--first-common-ancestor-in-region beg (- end 1))))
-    (and (= beg (js2-node-abs-pos ancestor))
-         (= end (js2-node-abs-end ancestor)))))
-
-
-;; executing a list of changes
-;; ensures changes are executed from last to first
-
-(defun js2r--by-end-descending (change1 change2)
-  (> (plist-get change1 :end)
-     (plist-get change2 :end)))
-
-(defun js2r--any-overlapping-changes (sorted-changes)
-  (--any?
-   (let ((one (car it))
-         (two (cadr it)))
-     (< (plist-get one :beg)
-        (plist-get two :end)))
-   (-partition-in-steps 2 1 sorted-changes)))
-
-(defun js2r--execute-changes (changes)
-  (when changes
-    (let ((sorted-changes (sort changes 'js2r--by-end-descending)))
-      (when (js2r--any-overlapping-changes sorted-changes)
-        (error "These changes overlap, cannot execute properly."))
-      (let ((abs-end (set-marker (make-marker) (1+ (plist-get (car sorted-changes) :end))))
-            (abs-beg (plist-get (car (last sorted-changes)) :beg)))
-        (--each sorted-changes
-          (goto-char (plist-get it :beg))
-          (delete-char (- (plist-get it :end) (plist-get it :beg)))
-          (insert (plist-get it :contents)))
-        (indent-region abs-beg abs-end)
-        (set-marker abs-end nil)))))
-
-(provide 'js2r-helpers)
-;;; js2-helpers.el ends here
diff --git a/elpa/js2-refactor-20190630.2108/js2r-helpers.elc b/elpa/js2-refactor-20190630.2108/js2r-helpers.elc
deleted file mode 100644
index 816c6d15..00000000
Binary files a/elpa/js2-refactor-20190630.2108/js2r-helpers.elc and /dev/null differ
diff --git a/elpa/js2-refactor-20190630.2108/js2r-iife.el b/elpa/js2-refactor-20190630.2108/js2r-iife.el
deleted file mode 100644
index f8893bba..00000000
--- a/elpa/js2-refactor-20190630.2108/js2r-iife.el
+++ /dev/null
@@ -1,92 +0,0 @@
-;;; js2r-iife.el --- IIFE wrapping functions for js2-refactor    -*- lexical-binding: t; -*-
-
-;; Copyright (C) 2012-2014 Magnar Sveen
-;; Copyright (C) 2015-2016 Magnar Sveen and Nicolas Petton
-
-;; Author: Magnar Sveen <magnars@gmail.com>,
-;;         Nicolas Petton <nicolas@petton.fr>
-;; Keywords: conveniences
-
-;; 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/>.
-
-;;; Code:
-
-(require 'js2r-helpers)
-
-(defvar js2r--iife-regexp "^(function (")
-
-(defun js2r-wrap-buffer-in-iife ()
-  "Wrap the entire buffer in an immediately invoked function expression"
-  (interactive)
-  (save-excursion
-    (when (ignore-errors (search-backward-regexp js2r--iife-regexp))
-      (error "Buffer already contains an immediately invoked function expression."))
-    (goto-char (point-min))
-    (insert "(function () {\n")
-    (when js2r-use-strict (insert "\"use strict\";\n"))
-    (insert "\n")
-    (goto-char (point-max))
-    (insert "\n")
-    (delete-blank-lines)
-    (insert "\n}());")
-    (indent-region (point-min) (point-max))))
-
-(defun js2r--selected-name-positions ()
-  "Returns the (beginning . end) of the name at cursor, or active region."
-  (let ((current-node (js2-node-at-point))
-        beg end)
-    (unless (js2-name-node-p current-node)
-      (setq current-node (js2-node-at-point (- (point) 1))))
-    (if (not (and current-node (js2-name-node-p current-node)))
-        (error "Point is not on an identifier."))
-    (if (use-region-p)
-        (cons (region-beginning) (region-end))
-      (progn
-        (setq end (+ (js2-node-abs-pos current-node)
-                     (js2-node-len current-node)))
-        (skip-syntax-backward ".w_")
-        (cons (point) end)))))
-
-(defun js2r-inject-global-in-iife ()
-  "Create shortcut for marked global by injecting it in the wrapping IIFE"
-  (interactive)
-  (js2r--guard)
-  (js2r--wait-for-parse
-   (save-excursion
-     (let* ((name-pos (js2r--selected-name-positions))
-	    (name-beg (car name-pos))
-	    (name-end (cdr name-pos))
-	    (name (buffer-substring-no-properties name-beg name-end))
-	    (short (buster--global-shortcut name))
-	    beg end)
-       (unless (search-backward-regexp js2r--iife-regexp)
-	 (error "No immediately invoked function expression found."))
-       (deactivate-mark)
-       (forward-char 11)
-       (insert short)
-       (unless (looking-at ")")
-	 (insert ", "))
-       (search-forward "{")
-       (setq beg (point))
-       (backward-char)
-       (forward-list)
-       (forward-char)
-       (setq end (point))
-       (insert name)
-       (unless (looking-at ")")
-	 (insert ", "))
-       (replace-string name short t beg end)))))
-
-(provide 'js2r-iife)
-;;; js2-iife.el ends here
diff --git a/elpa/js2-refactor-20190630.2108/js2r-iife.elc b/elpa/js2-refactor-20190630.2108/js2r-iife.elc
deleted file mode 100644
index a8c1e714..00000000
Binary files a/elpa/js2-refactor-20190630.2108/js2r-iife.elc and /dev/null differ
diff --git a/elpa/js2-refactor-20190630.2108/js2r-paredit.el b/elpa/js2-refactor-20190630.2108/js2r-paredit.el
deleted file mode 100644
index 39075584..00000000
--- a/elpa/js2-refactor-20190630.2108/js2r-paredit.el
+++ /dev/null
@@ -1,227 +0,0 @@
-;;; js2r-paredit.el --- Paredit-like extensions for js2-refactor    -*- lexical-binding: t; -*-
-
-;; Copyright (C) 2012-2014 Magnar Sveen
-;; Copyright (C) 2015-2016 Magnar Sveen and Nicolas Petton
-
-;; Author: Magnar Sveen <magnars@gmail.com>,
-;;         Nicolas Petton <nicolas@petton.fr>
-;; Keywords: conveniences
-
-;; 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/>.
-
-;;; Code:
-
-(require 'dash)
-
-(require 'js2r-helpers)
-
-(defun js2r--nesting-node-p (node)
-  (or (js2-function-node-p node)
-      (js2-if-node-p node)
-      (js2-for-node-p node)
-      (js2-while-node-p node)))
-
-(defun js2r--standalone-node-p (node)
-  (or (js2-stmt-node-p node)
-      (and (js2-function-node-p node)
-           (eq 'FUNCTION_STATEMENT (js2-function-node-form node)))))
-
-(defun js2r-kill ()
-  "Kill a line like `kill-line' but tries to respect node boundaries.
-Falls back to `kill-line' if the buffer has parse errors.
-
-if(|foo) {bar();}       -> if() {bar();}
-
-function foo() {|2 + 3} -> function foo() {}
-
-// some |comment        -> // some
-
-'this is a| string'     -> 'this is a'
-"
-  (interactive)
-  (if js2-parsed-errors
-      (progn
-        (message "Buffer has parse errors.  Killing the line")
-        (kill-line))
-    (condition-case error
-	(js2r--kill-line)
-      (progn
-	(message "Error occured while trying to kill AST node.  Killing the line.")
-	(kill-line)))))
-
-(defun js2r--kill-line ()
-  "Kill a line, but respecting node boundaries."
-  (let ((node (js2r--next-node)))
-    (cond
-     ((js2-comment-node-p node) (kill-line))
-     ((js2-string-node-p node) (js2r--kill-line-in-string))
-     (t (js2r--kill-line-in-sexp)))))
-
-(defun js2r--next-node ()
-  "Return the node at point, or the node after the point if the
-  point is at the exact end of a node."
-  (save-excursion
-    (when (= (js2-node-abs-end (js2-node-at-point))
-             (point))
-      (forward-char 1))
-    (js2-node-at-point)))
-
-(defun js2r--kill-line-in-sexp ()
-  "Kill a line, but only kills until the closest outer sexp on
-  the current line, delimited with \")}]\". If no sexp is found
-  on the current line, falls back to
-  `js2r--kill-line-with-inner-sexp'."
-  (condition-case error
-      (let* ((beg (point))
-             (end (save-excursion
-                    (up-list)
-                    (forward-char -1)
-                    (point))))
-        (if (js2-same-line end)
-            (kill-region beg end)
-          (js2r--kill-line-with-inner-sexp)))
-    (scan-error
-     (js2r--kill-line-with-inner-sexp))))
-
-(defun js2r--kill-line-with-inner-sexp ()
-  "Kill a line, but respecting inner killed sexps, ensuring that
-we kill up to the end to the next inner sexp if it starts in
-the current line.
-
-If the parentheses are unbalanced, fallback to `kill-line' and
-warn the user."
-  (condition-case error
-      (let* ((beg (point))
-             (end (save-excursion
-                    (forward-visible-line 1)
-                    (point)))
-             (beg-of-sexp (save-excursion
-                            (js2r--goto-last-sexp-on-line)
-                            (point)))
-             (end-of-sexp (save-excursion
-                            (goto-char beg-of-sexp)
-                            (forward-list)
-                            ;; Kill all remaining semi-colons as well
-                            (while (looking-at ";")
-                              (forward-char))
-                            (point))))
-        (if (js2-same-line beg-of-sexp)
-            (kill-region beg (max end end-of-sexp))
-          (kill-line)))
-    (scan-error
-     (message "Unbalanced parentheses. Killing the line.")
-     (kill-line))))
-
-(defun js2r--goto-last-sexp-on-line ()
-  "Move the cursor to the opening of the last sexp on the current
-line, or to the end of the line if no sexp is found."
-  (let ((pos (point)))
-    (down-list)
-    (backward-char 1)
-    (forward-list)
-    (if (js2-same-line pos)
-        (js2r--goto-last-sexp-on-line)
-      (backward-list))))
-
-(defun js2r--kill-line-in-string ()
-  "Kill a line in a string node, respecting the node boundaries.
-When at the beginning of the node, kill from outside of it."
-  (let* ((node (js2-node-at-point))
-         (beg (point))
-         (node-start (js2-node-abs-pos node))
-         (node-end (js2-node-abs-end node)))
-    (if (= beg node-start)
-        (js2r--kill-line-in-sexp)
-      (kill-region beg (1- node-end)))))
-
-(defun js2r-forward-slurp (&optional arg)
-  "Add the expression following the current function into it.
-
-The addition is performed by moving the closing brace of the
-function down.
-
-When called with a prefix argument ARG, slurp ARG expressions
-following the current function."
-  (interactive "p")
-  (js2r--guard)
-  (js2r--wait-for-parse
-   (let* ((nesting (js2r--closest 'js2r--nesting-node-p))
-	  (standalone (if (js2r--standalone-node-p nesting)
-			  nesting
-			(js2-node-parent-stmt nesting)))
-	  (next-sibling (js2-node-next-sibling standalone))
-	  (beg (js2-node-abs-pos next-sibling))
-	  (last-sibling (if (wholenump arg)
-			    (let ((num arg)
-				  (iter-sibling next-sibling))
-			      (while (> num 1) ;; Do next-sibling arg nbr of times
-				(setq iter-sibling (js2-node-next-sibling iter-sibling))
-				(setq num (1- num)))
-			      iter-sibling)
-			  next-sibling)) ;; No optional arg. Just use next-sibling
-	  (end (js2-node-abs-end last-sibling))
-	  (text (buffer-substring beg end)))
-     (save-excursion
-       (delete-region beg end)
-       ;; Delete newline character if the deleted AST node was at the end of the line
-       (goto-char beg)
-       (when (and (eolp)
-		  (not (eobp)))
-	 (delete-char 1))
-       (goto-char (js2-node-abs-end nesting))
-       (forward-char -1)
-       (when (looking-back "{ *")
-	 (newline))
-       (setq beg (point))
-       (insert text)
-       (when (looking-at " *}")
-	 (newline))
-       (setq end (point))
-       (indent-region beg end)))))
-
-(defun js2r-forward-barf (&optional arg)
-  (interactive "p")
-  (js2r--guard)
-  (js2r--wait-for-parse
-   (let* ((nesting (js2r--closest 'js2r--nesting-node-p))
-	  (standalone (if (js2r--standalone-node-p nesting)
-			  nesting
-			(js2-node-parent-stmt nesting)))
-	  (standalone-end (js2-node-abs-end standalone))
-	  (last-child (car (last (if (js2-if-node-p nesting)
-				     (js2-scope-kids (js2r--closest 'js2-scope-p))
-				   (js2r--node-kids nesting)))))
-	  (first-barf-child (if (wholenump arg)
-				(let ((num arg)
-				      (iter-child last-child))
-				  (while (> num 1) ;; Do prev-sibling arg nbr of times
-				    (setq iter-child (js2-node-prev-sibling iter-child))
-				    (setq num (1- num)))
-				  iter-child)
-			      last-child)) ; No optional arg. Just use last-child
-	  (last-child-beg (save-excursion
-			    (goto-char (js2-node-abs-pos first-barf-child))
-			    (skip-syntax-backward " ")
-			    (while (looking-back "\n") (backward-char))
-			    (point)))
-	  (last-child-end (js2-node-abs-end last-child))
-	  (text (buffer-substring last-child-beg last-child-end)))
-     (save-excursion
-       (js2r--execute-changes
-	(list
-	 (list :beg last-child-beg :end last-child-end :contents "")
-	 (list :beg standalone-end :end standalone-end :contents text)))))))
-
-(provide 'js2r-paredit)
-;;; js2r-paredit.el ends here
diff --git a/elpa/js2-refactor-20190630.2108/js2r-paredit.elc b/elpa/js2-refactor-20190630.2108/js2r-paredit.elc
deleted file mode 100644
index bd2b8314..00000000
Binary files a/elpa/js2-refactor-20190630.2108/js2r-paredit.elc and /dev/null differ
diff --git a/elpa/js2-refactor-20190630.2108/js2r-vars.el b/elpa/js2-refactor-20190630.2108/js2r-vars.el
deleted file mode 100644
index ffb9a320..00000000
--- a/elpa/js2-refactor-20190630.2108/js2r-vars.el
+++ /dev/null
@@ -1,375 +0,0 @@
-;;; js2r-vars.el --- Variable declaration manipulation functions for js2-refactor    -*- lexical-binding: t; -*-
-
-;; Copyright (C) 2012-2014 Magnar Sveen
-;; Copyright (C) 2015-2016 Magnar Sveen and Nicolas Petton
-
-;; Author: Magnar Sveen <magnars@gmail.com>,
-;;         Nicolas Petton <nicolas@petton.fr>
-;; Keywords: conveniences
-
-;; 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/>.
-
-;;; Code:
-
-(require 'multiple-cursors-core)
-(require 'dash)
-
-(require 'js2r-helpers)
-
-;; Helpers
-
-(defun js2r--name-node-at-point (&optional pos)
-  (setq pos (or pos (point)))
-  (let ((current-node (js2-node-at-point pos)))
-    (unless (js2-name-node-p current-node)
-      (setq current-node (js2-node-at-point (- (point) 1))))
-    (if (not (and current-node (js2-name-node-p current-node)))
-        (error "Point is not on an identifier.")
-      current-node)))
-
-(defun js2r--local-name-node-at-point (&optional pos)
-  (setq pos (or pos (point)))
-  (let ((current-node (js2r--name-node-at-point pos)))
-    (unless (js2r--local-name-node-p current-node)
-      (error "Point is not on a local identifier"))
-    current-node))
-
-(defun js2r--local-name-node-p (node)
-  (let ((parent (js2-node-parent node)))
-    (and parent (js2-name-node-p node)
-         ;; is not foo in { foo: 1 }
-         (not (and (js2-object-prop-node-p parent)
-                   (eq node (js2-object-prop-node-left parent))
-                   ;; could be { foo } though, in which case the node
-                   ;; is parent's both left and right.
-                   (not (eq node (js2-object-prop-node-right parent)))))
-         ;; is not foo in x.foo
-         (not (and (js2-prop-get-node-p parent)
-                   (eq node (js2-prop-get-node-right parent))))
-         ;; is not foo in import { foo as bar } from ...
-         ;; could be bar, though.
-         (not (and (js2-export-binding-node-p parent)
-                   (eq node (js2-export-binding-node-extern-name parent))
-                   (not (eq node (js2-export-binding-node-local-name parent))))))))
-
-(defun js2r--name-node-defining-scope (name-node)
-  (unless (js2r--local-name-node-p name-node)
-    (error "Node is not on a local identifier"))
-  (js2-get-defining-scope
-   (js2-node-get-enclosing-scope name-node)
-   (js2-name-node-name name-node)))
-
-(defun js2r--local-usages-of-name-node (name-node)
-  (unless (js2r--local-name-node-p name-node)
-    (error "Node is not on a local identifier"))
-  (let* ((name (js2-name-node-name name-node))
-         (scope (js2r--name-node-defining-scope name-node))
-         (result nil))
-    (js2-visit-ast
-     scope
-     (lambda (node end-p)
-       (when (and (not end-p)
-                  (js2r--local-name-node-p node)
-                  (string= name (js2-name-node-name node))
-                  (eq scope (js2r--name-node-defining-scope node)))
-         (add-to-list 'result node))
-       t))
-    result))
-
-(defun js2r--local-var-positions (name-node)
-  (-map 'js2-node-abs-pos (js2r--local-usages-of-name-node name-node)))
-
-(defun js2r--var-defining-node (var-node)
-  (unless (js2r--local-name-node-p var-node)
-    (error "Node is not on a local identifier"))
-  (let* ((name (js2-name-node-name var-node))
-         (scope (js2r--name-node-defining-scope var-node)))
-    (js2-symbol-ast-node
-     (js2-scope-get-symbol scope name))))
-
-
-;; Add to jslint globals annotation
-
-(defun current-line-contents ()
-  "Find the contents of the current line, minus indentation."
-  (buffer-substring (save-excursion (back-to-indentation) (point))
-                    (save-excursion (end-of-line) (point))))
-
-(require 'thingatpt)
-
-(defun js2r-add-to-globals-annotation ()
-  (interactive)
-  (let ((var (thing-at-point 'symbol)))
-    (save-excursion
-      (beginning-of-buffer)
-      (when (not (string-match "^/\\* *global " (current-line-contents)))
-        (newline)
-        (forward-line -1)
-        (insert "/* global */")
-        (newline)
-        (forward-line -1))
-      (while (not (string-match "*/" (current-line-contents)))
-        (forward-line))
-      (end-of-line)
-      (delete-char -2)
-      (unless (looking-back "global ")
-        (while (looking-back " ")
-          (delete-char -1))
-        (insert ", "))
-      (insert (concat var " */")))))
-
-
-;; Rename variable
-
-(defun js2r-rename-var ()
-  "Renames the variable on point and all occurrences in its lexical scope."
-  (interactive)
-  (js2r--guard)
-  (js2r--wait-for-parse
-   (let* ((current-node (js2r--local-name-node-at-point))
-	  (len (js2-node-len current-node))
-	  (current-start (js2-node-abs-pos current-node))
-	  (current-end (+ current-start len)))
-     (save-excursion
-       (mapc (lambda (beg)
-	       (when (not (= beg current-start))
-		 (goto-char beg)
-		 (set-mark (+ beg len))
-		 (mc/create-fake-cursor-at-point)))
-	     (js2r--local-var-positions current-node)))
-     (push-mark current-end)
-     (goto-char current-start)
-     (activate-mark))
-   (mc/maybe-multiple-cursors-mode)))
-
-(add-to-list 'mc--default-cmds-to-run-once 'js2r-rename-var)
-
-;; Change local variable to use this. instead
-
-(defun js2r-var-to-this ()
-  "Changes the variable on point to use this.var instead."
-  (interactive)
-  (js2r--guard)
-  (js2r--wait-for-parse
-   (save-excursion
-     (let ((node (js2-node-at-point)))
-       (when (js2-var-decl-node-p node)
-	 (let ((kids (js2-var-decl-node-kids node)))
-	   (when (cdr kids)
-	     (error "Currently does not support converting multivar statements."))
-	   (goto-char (js2-node-abs-pos (car kids))))))
-     (--each (js2r--local-var-positions (js2r--local-name-node-at-point))
-       (goto-char it)
-       (cond ((looking-back "var ") (delete-char -4))
-	     ((looking-back "let ") (delete-char -4))
-	     ((looking-back "const ") (delete-char -6)))
-       (insert "this.")))))
-
-;; Inline var
-
-(defun js2r-inline-var ()
-  (interactive)
-  (js2r--guard)
-  (js2r--wait-for-parse
-   (save-excursion
-     (let* ((current-node (js2r--local-name-node-at-point))
-	    (definer (js2r--var-defining-node current-node))
-	    (definer-start (js2-node-abs-pos definer))
-	    (var-init (js2-node-parent definer))
-	    (initializer (js2-var-init-node-initializer
-			  var-init)))
-       (unless initializer
-	 (error "Var is not initialized when defined."))
-       (let* ((var-len (js2-node-len current-node))
-	      (init-beg (js2-node-abs-pos initializer))
-	      (init-end (+ init-beg (js2-node-len initializer)))
-	      (var-init-beg (copy-marker (js2-node-abs-pos var-init)))
-	      (var-init-end (copy-marker (+ var-init-beg (js2-node-len var-init))))
-	      (contents (buffer-substring init-beg init-end)))
-	 (mapc (lambda (beg)
-		 (when (not (= beg definer-start))
-		   (goto-char beg)
-		   (delete-char var-len)
-		   (insert contents)))
-	       (js2r--local-var-positions current-node))
-	 (js2r--delete-var-init var-init-beg var-init-end))))))
-
-
-(defun js2r--was-single-var ()
-  (save-excursion
-    (goto-char (point-at-bol))
-    (or (looking-at "^[[:space:]]*\\(var\\|const\\|let\\)[[:space:]]?;?$")
-	(looking-at "^[[:space:]]*,[[:space:]]*$"))))
-
-(defun js2r--was-starting-var ()
-  (or (looking-back "var ")
-      (looking-back "const ")
-      (looking-back "let ")))
-
-(defun js2r--was-ending-var ()
-  (looking-at ";"))
-
-(defun js2r--delete-var-init (beg end)
-  (goto-char beg)
-  (delete-char (- end beg))
-  (cond
-   ((js2r--was-single-var)
-    (delete-region (point-at-bol) (point-at-eol))
-    (delete-blank-lines))
-
-   ((js2r--was-starting-var)
-    (delete-char 1)
-    (if (looking-at " ")
-        (delete-char 1)
-      (join-line -1)))
-
-   ((js2r--was-ending-var)
-    (if (looking-back ", ")
-        (delete-char -1)
-      (join-line)
-      (delete-char 1))
-    (delete-char -1))
-
-   (t (delete-char 2))))
-
-;; two cases
-;;   - it's the only var -> remove the line
-;;   - there are several vars -> remove the node then clean up commas
-
-
-;; Extract variable
-
-(defun js2r--start-of-parent-stmt ()
-  (js2-node-abs-pos (js2r--closest-stmt-node)))
-
-(defun js2r--object-literal-key-behind (pos)
-  (save-excursion
-    (goto-char pos)
-    (when (looking-back "\\sw: ?")
-      (backward-char 2)
-      (js2-name-node-name (js2r--name-node-at-point)))))
-
-(defun js2r--line-above-is-blank ()
-  (save-excursion
-    (forward-line -1)
-    (string= "" (current-line-contents))))
-
-;;;###autoload
-(defun js2r-extract-var ()
-  (interactive)
-  (js2r--guard)
-  (js2r--wait-for-parse
-   (let ((keyword (if js2r-prefer-let-over-var "let" "var")))
-        (if (use-region-p)
-            (js2r--extract-var-between (region-beginning) (region-end) keyword)
-          (let ((node (js2r--closest-extractable-node)))
-            (js2r--extract-var-between (js2-node-abs-pos node)
-                                       (js2-node-abs-end node) keyword))))))
-
-;;;###autoload
-(defun js2r-extract-let ()
-  (interactive)
-  (js2r--guard)
-  (js2r--wait-for-parse
-   (if (use-region-p)
-       (js2r--extract-var-between (region-beginning) (region-end) "let")
-     (let ((node (js2r--closest-extractable-node)))
-       (js2r--extract-var-between (js2-node-abs-pos node)
-                                  (js2-node-abs-end node) "let")))))
-
-;;;###autoload
-(defun js2r-extract-const ()
-  (interactive)
-  (js2r--guard)
-  (js2r--wait-for-parse
-   (if (use-region-p)
-       (js2r--extract-var-between (region-beginning) (region-end) "const")
-     (let ((node (js2r--closest-extractable-node)))
-       (js2r--extract-var-between (js2-node-abs-pos node)
-                                  (js2-node-abs-end node) "const")))))
-
-(add-to-list 'mc--default-cmds-to-run-once 'js2r-extract-var)
-(add-to-list 'mc--default-cmds-to-run-once 'js2r-extract-let)
-(add-to-list 'mc--default-cmds-to-run-once 'js2r-extract-const)
-
-(defun js2r--extract-var-between (beg end keyword)
-  (interactive "r")
-  (unless (js2r--single-complete-expression-between-p beg end)
-    (error "Can only extract single, complete expressions to var"))
-
-  (let ((deactivate-mark nil)
-        (expression (buffer-substring beg end))
-        (orig-var-end (make-marker))
-        (new-var-end (make-marker))
-        (name (or (js2r--object-literal-key-behind beg) "name")))
-
-    (delete-region beg end)
-    (insert name)
-    (set-marker orig-var-end (point))
-
-    (goto-char (js2r--start-of-parent-stmt))
-    (js2r--insert-var name keyword)
-    (set-marker new-var-end (point))
-    (insert " = " expression ";")
-    (when (or (js2r--line-above-is-blank)
-              (string-match-p "^function " expression))
-      (newline))
-    (newline)
-    (indent-region new-var-end orig-var-end)
-    (save-excursion
-      (goto-char new-var-end)
-      (set-mark (- (point) (length name)))
-      (mc/create-fake-cursor-at-point))
-    (goto-char orig-var-end)
-    (set-mark (- (point) (length name)))
-    (set-marker orig-var-end nil)
-    (set-marker new-var-end nil))
-  (mc/maybe-multiple-cursors-mode))
-
-(defun js2r--insert-var (name keyword)
-  "Insert a var definition for NAME."
-  (insert (format "%s %s" keyword name)))
-
-(defun js2r-split-var-declaration ()
-  "Split a variable declaration into separate variable
-declarations for each declared variable."
-  (interactive)
-  (js2r--guard)
-  (js2r--wait-for-parse
-   (save-excursion
-     (let* ((declaration (or (js2r--closest #'js2-var-decl-node-p) (error "No var declaration at point.")))
-	    (kids (js2-var-decl-node-kids declaration))
-	    (stmt (js2-node-parent-stmt declaration))
-        (tt (js2-var-decl-node-decl-type declaration))
-        (keyword (cond
-                  ((= tt js2-VAR) "var")
-                  ((= tt js2-LET) "let")
-                  ((= tt js2-CONST) "const"))))
-       (goto-char (js2-node-abs-end stmt))
-       (mapc (lambda (kid)
-           (js2r--insert-var (js2-node-string kid) keyword)
-	       (insert ";")
-	       (newline)
-	       (if (save-excursion
-		     (goto-char (js2-node-abs-end kid))
-		     (looking-at ", *\n *\n"))
-		   (newline)))
-	     kids)
-       (delete-char -1) ;; delete final newline
-       (let ((end (point)))
-	 (js2r--goto-and-delete-node stmt)
-	 (indent-region (point) end))))))
-
-(provide 'js2r-vars)
-;;; js2-vars.el ends here
diff --git a/elpa/js2-refactor-20190630.2108/js2r-vars.elc b/elpa/js2-refactor-20190630.2108/js2r-vars.elc
deleted file mode 100644
index a9a92940..00000000
Binary files a/elpa/js2-refactor-20190630.2108/js2r-vars.elc and /dev/null differ
diff --git a/elpa/js2-refactor-20190630.2108/js2r-wrapping.el b/elpa/js2-refactor-20190630.2108/js2r-wrapping.el
deleted file mode 100644
index 9e437807..00000000
--- a/elpa/js2-refactor-20190630.2108/js2r-wrapping.el
+++ /dev/null
@@ -1,76 +0,0 @@
-;;; js2r-wrapping.el --- Helper functions for wrapping/unwrapping  -*- lexical-binding: t; -*-
-
-;; Copyright (C) 2017  Nicolas Petton
-
-;; Author: Nicolas Petton
-
-;; 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:
-
-;;
-
-;;; Code:
-
-(require 'yasnippet)
-
-(require 'js2r-helpers)
-
-(defvar js2r--space-str " \t\n")
-
-(defun js2r--skip-region-whitespace ()
-  (let ((p-first (< (point) (mark))))
-    (unless p-first
-      (exchange-point-and-mark))
-    (skip-chars-forward js2r--space-str)
-    (exchange-point-and-mark)
-    (skip-chars-backward js2r--space-str)
-    (when p-first
-      (exchange-point-and-mark))))
-
-(defun js2r-unwrap ()
-  (interactive)
-  (js2r--guard)
-  (js2r--wait-for-parse
-   (let (beg end)
-     (if (use-region-p)
-	 (progn
-	   (js2r--skip-region-whitespace)
-	   (setq beg (min (point) (mark)))
-	   (setq end (max (point) (mark))))
-       (let ((stmt (js2-node-parent-stmt (js2-node-at-point))))
-	 (setq beg (js2-node-abs-pos stmt))
-	 (setq end (js2-node-abs-end stmt))))
-     (let* ((ancestor (js2-node-parent-stmt
-		       (js2r--first-common-ancestor-in-region beg end)))
-	    (abeg (js2-node-abs-pos ancestor))
-	    (aend (js2-node-abs-end ancestor)))
-       (save-excursion
-	 (goto-char end)
-	 (delete-char (- aend end))
-	 (goto-char abeg)
-	 (delete-char (- beg abeg)))
-       (indent-region (point-min) (point-max))))))
-
-(defun js2r-wrap-in-for-loop (beg end)
-  (interactive "r")
-  (js2r--skip-region-whitespace)
-  (setq beg (min (point) (mark)))
-  (setq end (max (point) (mark)))
-  (let ((yas-wrap-around-region t))
-    (yas-expand-snippet "for (var i = 0, l = ${1:length}; i < l; i++) {\n$0\n}"
-                        beg end)))
-
-(provide 'js2r-wrapping)
-;;; js2r-wrapping.el ends here
diff --git a/elpa/js2-refactor-20190630.2108/js2r-wrapping.elc b/elpa/js2-refactor-20190630.2108/js2r-wrapping.elc
deleted file mode 100644
index 3a052d22..00000000
Binary files a/elpa/js2-refactor-20190630.2108/js2r-wrapping.elc and /dev/null differ
diff --git a/elpa/multiple-cursors-20191210.1759/mc-cycle-cursors.el b/elpa/multiple-cursors-20191210.1759/mc-cycle-cursors.el
deleted file mode 100644
index 85af3529..00000000
--- a/elpa/multiple-cursors-20191210.1759/mc-cycle-cursors.el
+++ /dev/null
@@ -1,119 +0,0 @@
-;;; mc-cycle-cursors.el
-
-;; Copyright (C) 2012-2016 Magnar Sveen
-
-;; Author: Magnar Sveen <magnars@gmail.com>
-;; Keywords: editing cursors
-
-;; This program is free software; you can redistribute it and/or modify
-;; it under the terms of the GNU General Public License as published by
-;; the Free Software Foundation, either version 3 of the License, or
-;; (at your option) any later version.
-
-;; This program is distributed in the hope that it will be useful,
-;; but WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-;; GNU General Public License for more details.
-
-;; You should have received a copy of the GNU General Public License
-;; along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-;;; Commentary:
-
-;; This scrolls the buffer to center each cursor in turn.
-;; Scroll down with C-v, scroll up with M-v
-;; This is nice when you have cursors that's outside of your view.
-
-;;; Code:
-
-(require 'multiple-cursors-core)
-
-(defun mc/next-fake-cursor-after-point ()
-  (let ((pos (point))
-        (next-pos (1+ (point-max)))
-        next)
-    (mc/for-each-fake-cursor
-     (let ((cursor-pos (overlay-get cursor 'point)))
-       (when (and (< pos cursor-pos)
-                  (< cursor-pos next-pos))
-         (setq next-pos cursor-pos)
-         (setq next cursor))))
-    next))
-
-(defun mc/prev-fake-cursor-before-point ()
-  (let ((pos (point))
-        (prev-pos (1- (point-min)))
-        prev)
-    (mc/for-each-fake-cursor
-     (let ((cursor-pos (overlay-get cursor 'point)))
-       (when (and (> pos cursor-pos)
-                  (> cursor-pos prev-pos))
-         (setq prev-pos cursor-pos)
-         (setq prev cursor))))
-    prev))
-
-(defcustom mc/cycle-looping-behaviour 'continue
-  "What to do if asked to cycle beyond the last cursor or before the first cursor."
-  :type '(radio (const :tag "Loop around to beginning/end of document." continue)
-                (const :tag "Warn and then loop around." warn)
-                (const :tag "Signal an error." error)
-                (const :tag "Don't loop." stop))
-  :group 'multiple-cursors)
-
-(defun mc/handle-loop-condition (error-message)
-  (cl-ecase mc/cycle-looping-behaviour
-    (error (error error-message))
-    (warn  (message error-message))
-    (continue 'continue)
-    (stop 'stop)))
-
-(defun mc/first-fake-cursor-after (point)
-  "Very similar to mc/furthest-cursor-before-point, but ignores (mark) and (point)."
-  (let* ((cursors (mc/all-fake-cursors))
-         (cursors-after-point (cl-remove-if (lambda (cursor)
-                                              (< (mc/cursor-beg cursor) point))
-                                            cursors))
-         (cursors-in-order (cl-sort cursors-after-point '< :key 'mc/cursor-beg)))
-    (car cursors-in-order)))
-
-(defun mc/last-fake-cursor-before (point)
-  "Very similar to mc/furthest-cursor-before-point, but ignores (mark) and (point)."
-  (let* ((cursors (mc/all-fake-cursors))
-         (cursors-before-point (cl-remove-if (lambda (cursor)
-                                               (> (mc/cursor-end cursor) point))
-                                             cursors))
-         (cursors-in-order (cl-sort cursors-before-point '> :key 'mc/cursor-end)))
-    (car cursors-in-order)))
-
-(cl-defun mc/cycle (next-cursor fallback-cursor loop-message)
-  (when (null next-cursor)
-    (when (eql 'stop (mc/handle-loop-condition loop-message))
-      (return-from mc/cycle nil))
-    (setf next-cursor fallback-cursor))
-  (mc/create-fake-cursor-at-point)
-  (mc/pop-state-from-overlay next-cursor)
-  (recenter))
-
-(defun mc/cycle-forward ()
-  (interactive)
-  (mc/cycle (mc/next-fake-cursor-after-point)
-            (mc/first-fake-cursor-after (point-min))
-             "We're already at the last cursor."))
-
-(defun mc/cycle-backward ()
-  (interactive)
-  (mc/cycle (mc/prev-fake-cursor-before-point)
-            (mc/last-fake-cursor-before (point-max))
-            "We're already at the last cursor"))
-
-(define-key mc/keymap (kbd "C-v") 'mc/cycle-forward)
-(define-key mc/keymap (kbd "M-v") 'mc/cycle-backward)
-
-(provide 'mc-cycle-cursors)
-
-
-;; Local Variables:
-;; coding: utf-8
-;; End:
-
-;;; mc-cycle-cursors.el ends here
diff --git a/elpa/multiple-cursors-20191210.1759/mc-cycle-cursors.elc b/elpa/multiple-cursors-20191210.1759/mc-cycle-cursors.elc
deleted file mode 100644
index 0b765d1b..00000000
Binary files a/elpa/multiple-cursors-20191210.1759/mc-cycle-cursors.elc and /dev/null differ
diff --git a/elpa/multiple-cursors-20191210.1759/mc-edit-lines.el b/elpa/multiple-cursors-20191210.1759/mc-edit-lines.el
deleted file mode 100644
index 55772afa..00000000
--- a/elpa/multiple-cursors-20191210.1759/mc-edit-lines.el
+++ /dev/null
@@ -1,110 +0,0 @@
-;;; mc-edit-lines.el
-
-;; Copyright (C) 2012-2016 Magnar Sveen
-
-;; Author: Magnar Sveen <magnars@gmail.com>
-;; Keywords: editing cursors
-
-;; This program is free software; you can redistribute it and/or modify
-;; it under the terms of the GNU General Public License as published by
-;; the Free Software Foundation, either version 3 of the License, or
-;; (at your option) any later version.
-
-;; This program is distributed in the hope that it will be useful,
-;; but WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-;; GNU General Public License for more details.
-
-;; You should have received a copy of the GNU General Public License
-;; along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-;;; Commentary:
-
-;; This file contains functions to add multiple cursors to consecutive lines
-;; given an active region.
-
-;; Please see multiple-cursors.el for more commentary.
-
-;;; Code:
-
-(require 'multiple-cursors-core)
-
-(defcustom mc/edit-lines-empty-lines nil
-  "What should be done by `mc/edit-lines' when a line is not long enough."
-  :type '(radio (const :tag "Pad the line with spaces." pad)
-                (const :tag "Ignore the line." ignore)
-                (const :tag "Signal an error." error)
-                (const :tag "Nothing.  Cursor is at end of line." nil))
-  :group 'multiple-cursors)
-
-;;;###autoload
-(defun mc/edit-lines (&optional arg)
-  "Add one cursor to each line of the active region.
-Starts from mark and moves in straight down or up towards the
-line point is on.
-
-What is done with lines which are not long enough is governed by
-`mc/edit-lines-empty-lines'.  The prefix argument ARG can be used
-to override this.  If ARG is a symbol (when called from Lisp),
-that symbol is used instead of `mc/edit-lines-empty-lines'.
-Otherwise, if ARG negative, short lines will be ignored.  Any
-other non-nil value will cause short lines to be padded."
-  (interactive "P")
-  (when (not (and mark-active (/= (point) (mark))))
-    (error "Mark a set of lines first"))
-  (mc/remove-fake-cursors)
-  (let* ((col (current-column))
-         (point-line (mc/line-number-at-pos))
-         (mark-line (progn (exchange-point-and-mark) (mc/line-number-at-pos)))
-         (direction (if (< point-line mark-line) :up :down))
-         (style (cond
-                 ;; called from lisp
-                 ((and arg (symbolp arg))
-                  arg)
-                 ;; negative argument
-                 ((< (prefix-numeric-value arg) 0)
-                  'ignore)
-                 (arg 'pad)
-                 (t mc/edit-lines-empty-lines))))
-    (deactivate-mark)
-    (when (and (eq direction :up) (bolp))
-      (previous-logical-line 1 nil)
-      (move-to-column col))
-    ;; Add the cursors
-    (while (not (eq (mc/line-number-at-pos) point-line))
-      ;; Pad the line
-      (when (eq style 'pad)
-        (while (< (current-column) col)
-          (insert " ")))
-      ;; Error
-      (when (and (eq style 'error)
-                 (not (equal col (current-column))))
-        (error "Short line encountered in `mc/edit-lines'"))
-      ;; create the cursor
-      (unless (and (eq style 'ignore)
-                   (not (equal col (current-column))))
-        (mc/create-fake-cursor-at-point))
-      ;; proceed to next
-      (if (eq direction :up)
-          (previous-logical-line 1 nil)
-        (next-logical-line 1 nil))
-      (move-to-column col))
-    (multiple-cursors-mode)))
-
-;;;###autoload
-(defun mc/edit-ends-of-lines ()
-  "Add one cursor to the end of each line in the active region."
-  (interactive)
-  (mc/edit-lines)
-  (mc/execute-command-for-all-cursors 'end-of-line))
-
-;;;###autoload
-(defun mc/edit-beginnings-of-lines ()
-  "Add one cursor to the beginning of each line in the active region."
-  (interactive)
-  (mc/edit-lines)
-  (mc/execute-command-for-all-cursors 'beginning-of-line))
-
-(provide 'mc-edit-lines)
-
-;;; mc-edit-lines.el ends here
diff --git a/elpa/multiple-cursors-20191210.1759/mc-edit-lines.elc b/elpa/multiple-cursors-20191210.1759/mc-edit-lines.elc
deleted file mode 100644
index f8855ff8..00000000
Binary files a/elpa/multiple-cursors-20191210.1759/mc-edit-lines.elc and /dev/null differ
diff --git a/elpa/multiple-cursors-20191210.1759/mc-hide-unmatched-lines-mode.el b/elpa/multiple-cursors-20191210.1759/mc-hide-unmatched-lines-mode.el
deleted file mode 100644
index 0167dbcd..00000000
--- a/elpa/multiple-cursors-20191210.1759/mc-hide-unmatched-lines-mode.el
+++ /dev/null
@@ -1,107 +0,0 @@
-;;; mc-hide-unmatched-lines.el
-
-;; Copyright (C) 2014 Aleksey Fedotov
-
-;; Author: Aleksey Fedotov <lexa@cfotr.com>
-;; Keywords: editing cursors
-
-;; This program is free software; you can redistribute it and/or modify
-;; it under the terms of the GNU General Public License as published by
-;; the Free Software Foundation, either version 3 of the License, or
-;; (at your option) any later version.
-
-;; This program is distributed in the hope that it will be useful,
-;; but WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-;; GNU General Public License for more details.
-
-;; You should have received a copy of the GNU General Public License
-;; along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-;;; Commentary:
-
-;; This minor mode when enabled hides all lines where no cursors (and
-;; also hum/lines-to-expand below and above) To make use of this mode
-;; press "C-'" while multiple-cursor-mode is active. You can still
-;; edit lines while you are in mc-hide-unmatched-lines mode. To leave
-;; this mode press "<return>" or "C-g"
-;;
-
-;;; Code:
-
-(require 'multiple-cursors-core)
-(require 'mc-mark-more)
-
-(defvar hum/hide-unmatched-lines-mode-map (make-sparse-keymap)
-  "Keymap for hide unmatched lines is mainly for rebinding C-g")
-
-(define-key hum/hide-unmatched-lines-mode-map (kbd "C-g") 'hum/keyboard-quit)
-(define-key hum/hide-unmatched-lines-mode-map (kbd "<return>") 'hum/keyboard-quit)
-
-(defun hum/keyboard-quit ()
-  "Leave hide-unmatched-lines mode"
-  (interactive)
-  (mc-hide-unmatched-lines-mode 0))
-
-;; used only in in multiple-cursors-mode-disabled-hook
-(defun hum/disable-hum-mode ()
-  (mc-hide-unmatched-lines-mode 0))
-
-;;;###autoload
-(define-minor-mode mc-hide-unmatched-lines-mode
-  "Minor mode when enabled hides all lines where no cursors (and
-also hum/lines-to-expand below and above) To make use of this
-mode press \"C-'\" while multiple-cursor-mode is active. You can
-still edit lines while you are in mc-hide-unmatched-lines
-mode. To leave this mode press <return> or \"C-g\""
-  nil " hu"
-  hum/hide-unmatched-lines-mode-map
-  (if mc-hide-unmatched-lines-mode
-      ;;just in case if mc mode will be disabled while hide-unmatched-lines is active
-      (progn
-        (hum/hide-unmatched-lines)
-        (add-hook 'multiple-cursors-mode-disabled-hook 'hum/disable-hum-mode t t))
-    (progn
-      (hum/unhide-unmatched-lines)
-      (remove-hook 'multiple-cursors-mode-disabled-hook 'hum/disable-hum-mode))))
-
-(defconst hum/invisible-overlay-name 'hum/invisible-overlay-name)
-
-(defcustom hum/lines-to-expand 2
-  "How many lines below and above cursor to show"
-  :type '(integer)
-  :group 'multiple-cursors)
-
-(defcustom hum/placeholder "..."
-  "Placeholder which will be placed instead of hidden text"
-  :type '(string)
-  :group 'multiple-cursors)
-
-(defun hum/add-invisible-overlay (begin end)
-  (let ((overlay (make-overlay begin
-                               end
-                               (current-buffer)
-                               t
-                               nil
-                               )))
-    (overlay-put overlay hum/invisible-overlay-name t)
-    (overlay-put overlay 'invisible t)
-    (overlay-put overlay 'intangible t)
-    (overlay-put overlay 'evaporate t)
-    (overlay-put overlay 'after-string hum/placeholder)))
-
-(defun hum/hide-unmatched-lines ()
-  (let ((begin (point-min)))
-    (mc/for-each-cursor-ordered
-     (save-excursion
-       (goto-char (mc/cursor-beg cursor))
-       (if (< begin (line-beginning-position (- hum/lines-to-expand)))
-           (hum/add-invisible-overlay begin (line-end-position (- hum/lines-to-expand))))
-       (setq begin (line-beginning-position (+ 2 hum/lines-to-expand)))))
-    (hum/add-invisible-overlay begin (point-max))))
-
-(defun hum/unhide-unmatched-lines ()
-  (remove-overlays nil nil hum/invisible-overlay-name t))
-
-(provide 'mc-hide-unmatched-lines-mode)
-(define-key mc/keymap (kbd "C-'") 'mc-hide-unmatched-lines-mode)
diff --git a/elpa/multiple-cursors-20191210.1759/mc-hide-unmatched-lines-mode.elc b/elpa/multiple-cursors-20191210.1759/mc-hide-unmatched-lines-mode.elc
deleted file mode 100644
index a4741c52..00000000
Binary files a/elpa/multiple-cursors-20191210.1759/mc-hide-unmatched-lines-mode.elc and /dev/null differ
diff --git a/elpa/multiple-cursors-20191210.1759/mc-mark-more.el b/elpa/multiple-cursors-20191210.1759/mc-mark-more.el
deleted file mode 100644
index 2e631307..00000000
--- a/elpa/multiple-cursors-20191210.1759/mc-mark-more.el
+++ /dev/null
@@ -1,709 +0,0 @@
-;;; mc-mark-more.el
-
-;; Copyright (C) 2012-2016 Magnar Sveen
-
-;; Author: Magnar Sveen <magnars@gmail.com>
-;; Keywords: editing cursors
-
-;; This program is free software; you can redistribute it and/or modify
-;; it under the terms of the GNU General Public License as published by
-;; the Free Software Foundation, either version 3 of the License, or
-;; (at your option) any later version.
-
-;; This program is distributed in the hope that it will be useful,
-;; but WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-;; GNU General Public License for more details.
-
-;; You should have received a copy of the GNU General Public License
-;; along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-;;; Commentary:
-
-;; This file contains functions to mark more parts of the buffer.
-;; See ./features/mark-more.feature for examples.
-
-;; Please see multiple-cursors.el for more commentary.
-
-;;; Code:
-
-(require 'multiple-cursors-core)
-(require 'thingatpt)
-
-(defun mc/cursor-end (cursor)
-  (if (overlay-get cursor 'mark-active)
-      (max (overlay-get cursor 'point)
-           (overlay-get cursor 'mark))
-    (overlay-get cursor 'point)))
-
-(defun mc/cursor-beg (cursor)
-  (if (overlay-get cursor 'mark-active)
-      (min (overlay-get cursor 'point)
-           (overlay-get cursor 'mark))
-    (overlay-get cursor 'point)))
-
-(defun mc/furthest-region-end ()
-  (let ((end (max (mark) (point))))
-    (mc/for-each-fake-cursor
-     (setq end (max end (mc/cursor-end cursor))))
-    end))
-
-(defun mc/first-region-start ()
-  (let ((beg (min (mark) (point))))
-    (mc/for-each-fake-cursor
-     (setq beg (min beg (mc/cursor-beg cursor))))
-    beg))
-
-(defun mc/furthest-cursor-before-point ()
-  (let ((beg (if mark-active (min (mark) (point)) (point)))
-        furthest)
-    (mc/for-each-fake-cursor
-     (when (< (mc/cursor-beg cursor) beg)
-       (setq beg (mc/cursor-beg cursor))
-       (setq furthest cursor)))
-    furthest))
-
-(defun mc/furthest-cursor-after-point ()
-  (let ((end (if mark-active (max (mark) (point)) (point)))
-        furthest)
-    (mc/for-each-fake-cursor
-     (when (> (mc/cursor-end cursor) end)
-       (setq end (mc/cursor-end cursor))
-       (setq furthest cursor)))
-    furthest))
-
-(defun mc/fake-cursor-at-point (&optional point)
-  "Return the fake cursor with its point right at POINT (defaults
-to (point)), or nil."
-  (setq point (or point (point)))
-  (let ((cursors (mc/all-fake-cursors))
-        (c nil))
-    (catch 'found
-      (while (setq c (pop cursors))
-        (when (eq (marker-position (overlay-get c 'point))
-                  point)
-          (throw 'found c))))))
-
-(defun mc/region-strings ()
-  (let ((strings (list (buffer-substring-no-properties (point) (mark)))))
-    (mc/for-each-fake-cursor
-     (add-to-list 'strings (buffer-substring-no-properties
-                            (mc/cursor-beg cursor)
-                            (mc/cursor-end cursor))))
-    strings))
-
-(defvar mc/enclose-search-term nil
-  "How should mc/mark-more-* search for more matches?
-
-Match everything: nil
-Match only whole words: 'words
-Match only whole symbols: 'symbols
-
-Use like case-fold-search, don't recommend setting it globally.")
-
-(defun mc/mark-more-like-this (skip-last direction)
-  (let ((case-fold-search nil)
-        (re (regexp-opt (mc/region-strings) mc/enclose-search-term))
-        (point-out-of-order (cl-ecase direction
-                              (forwards       (< (point) (mark)))
-                              (backwards (not (< (point) (mark))))))
-        (furthest-cursor (cl-ecase direction
-                           (forwards  (mc/furthest-cursor-after-point))
-                           (backwards (mc/furthest-cursor-before-point))))
-        (start-char (cl-ecase direction
-                      (forwards  (mc/furthest-region-end))
-                      (backwards (mc/first-region-start))))
-        (search-function (cl-ecase direction
-                           (forwards  'search-forward-regexp)
-                           (backwards 'search-backward-regexp)))
-        (match-point-getter (cl-ecase direction
-                              (forwards 'match-beginning)
-                              (backwards 'match-end))))
-    (if (and skip-last (not furthest-cursor))
-        (error "No cursors to be skipped")
-      (mc/save-excursion
-       (goto-char start-char)
-       (when skip-last
-         (mc/remove-fake-cursor furthest-cursor))
-       (if (funcall search-function re nil t)
-           (progn
-             (push-mark (funcall match-point-getter 0))
-             (when point-out-of-order
-               (exchange-point-and-mark))
-             (mc/create-fake-cursor-at-point))
-         (user-error "no more matches found."))))))
-
-;;;###autoload
-(defun mc/mark-next-like-this (arg)
-  "Find and mark the next part of the buffer matching the currently active region
-If no region is active add a cursor on the next line
-With negative ARG, delete the last one instead.
-With zero ARG, skip the last one and mark next."
-  (interactive "p")
-  (if (< arg 0)
-      (let ((cursor (mc/furthest-cursor-after-point)))
-        (if cursor
-            (mc/remove-fake-cursor cursor)
-          (error "No cursors to be unmarked")))
-    (if (region-active-p)
-        (mc/mark-more-like-this (= arg 0) 'forwards)
-      (mc/mark-lines arg 'forwards)))
-  (mc/maybe-multiple-cursors-mode))
-
-;;;###autoload
-(defun mc/mark-next-like-this-word (arg)
-  "Find and mark the next part of the buffer matching the currently active region
-If no region is active, mark the word at the point and find the next match
-With negative ARG, delete the last one instead.
-With zero ARG, skip the last one and mark next."
-  (interactive "p")
-  (if (< arg 0)
-      (let ((cursor (mc/furthest-cursor-after-point)))
-        (if cursor
-            (mc/remove-fake-cursor cursor)
-          (error "No cursors to be unmarked")))
-    (if (region-active-p)
-        (mc/mark-more-like-this (= arg 0) 'forwards)
-      (mc--select-thing-at-point 'word)
-      (mc/mark-more-like-this (= arg 0) 'forwards)))
-  (mc/maybe-multiple-cursors-mode))
-
-(defun mc/mark-next-like-this-symbol (arg)
-  "Find and mark the next part of the buffer matching the currently active region
-If no region is active, mark the symbol at the point and find the next match
-With negative ARG, delete the last one instead.
-With zero ARG, skip the last one and mark next."
-  (interactive "p")
-  (if (< arg 0)
-      (let ((cursor (mc/furthest-cursor-after-point)))
-        (if cursor
-            (mc/remove-fake-cursor cursor)
-          (error "No cursors to be unmarked")))
-    (if (region-active-p)
-        (mc/mark-more-like-this (= arg 0) 'forwards)
-      (mc--select-thing-at-point 'symbol)
-      (mc/mark-more-like-this (= arg 0) 'forwards)))
-  (mc/maybe-multiple-cursors-mode))
-
-
-;;;###autoload
-(defun mc/mark-next-word-like-this (arg)
-  "Find and mark the next word of the buffer matching the currently active region
-The matching region must be a whole word to be a match
-If no region is active, mark the symbol at the point and find the next match
-With negative ARG, delete the last one instead.
-With zero ARG, skip the last one and mark next."
-  (interactive "p")
-  (let ((mc/enclose-search-term 'words))
-    (mc/mark-next-like-this arg)))
-
-;;;###autoload
-(defun mc/mark-next-symbol-like-this (arg)
-  "Find and mark the next symbol of the buffer matching the currently active region
-The matching region must be a whole symbol to be a match
-If no region is active, mark the symbol at the point and find the next match
-With negative ARG, delete the last one instead.
-With zero ARG, skip the last one and mark next."
-  (interactive "p")
-  (let ((mc/enclose-search-term 'symbols))
-    (mc/mark-next-like-this arg)))
-
-;;;###autoload
-(defun mc/mark-previous-like-this (arg)
-  "Find and mark the previous part of the buffer matching the currently active region
-If no region is active add a cursor on the previous line
-With negative ARG, delete the last one instead.
-With zero ARG, skip the last one and mark next."
-  (interactive "p")
-  (if (< arg 0)
-      (let ((cursor (mc/furthest-cursor-before-point)))
-        (if cursor
-            (mc/remove-fake-cursor cursor)
-          (error "No cursors to be unmarked")))
-    (if (region-active-p)
-        (mc/mark-more-like-this (= arg 0) 'backwards)
-      (mc/mark-lines arg 'backwards)))
-  (mc/maybe-multiple-cursors-mode))
-
-;;;###autoload
-(defun mc/mark-previous-like-this-word (arg)
-  "Find and mark the previous part of the buffer matching the currently active region
-If no region is active, mark the word at the point and find the previous match
-With negative ARG, delete the last one instead.
-With zero ARG, skip the last one and mark previous."
-  (interactive "p")
-  (if (< arg 0)
-      (let ((cursor (mc/furthest-cursor-after-point)))
-        (if cursor
-            (mc/remove-fake-cursor cursor)
-          (error "No cursors to be unmarked")))
-    (if (region-active-p)
-        (mc/mark-more-like-this (= arg 0) 'backwards)
-      (mc--select-thing-at-point 'word)
-      (mc/mark-more-like-this (= arg 0) 'backwards)))
-  (mc/maybe-multiple-cursors-mode))
-
-(defun mc/mark-previous-like-this-symbol (arg)
-  "Find and mark the previous part of the buffer matching the currently active region
-If no region is active, mark the symbol at the point and find the previous match
-With negative ARG, delete the last one instead.
-With zero ARG, skip the last one and mark previous."
-  (interactive "p")
-  (if (< arg 0)
-      (let ((cursor (mc/furthest-cursor-after-point)))
-        (if cursor
-            (mc/remove-fake-cursor cursor)
-          (error "No cursors to be unmarked")))
-    (if (region-active-p)
-        (mc/mark-more-like-this (= arg 0) 'backwards)
-      (mc--select-thing-at-point 'symbol)
-      (mc/mark-more-like-this (= arg 0) 'backwards)))
-  (mc/maybe-multiple-cursors-mode))
-
-
-;;;###autoload
-(defun mc/mark-previous-word-like-this (arg)
-  "Find and mark the previous part of the buffer matching the currently active region
-The matching region must be a whole word to be a match
-If no region is active add a cursor on the previous line
-With negative ARG, delete the last one instead.
-With zero ARG, skip the last one and mark next."
-  (interactive "p")
-  (let ((mc/enclose-search-term 'words))
-    (mc/mark-previous-like-this arg)))
-
-;;;###autoload
-(defun mc/mark-previous-symbol-like-this (arg)
-  "Find and mark the previous part of the buffer matching the currently active region
-The matching region must be a whole symbol to be a match
-If no region is active add a cursor on the previous line
-With negative ARG, delete the last one instead.
-With zero ARG, skip the last one and mark next."
-  (interactive "p")
-  (let ((mc/enclose-search-term 'symbols))
-    (mc/mark-previous-like-this arg)))
-
-(defun mc/mark-lines (num-lines direction)
-  (dotimes (i (if (= num-lines 0) 1 num-lines))
-    (mc/save-excursion
-     (let ((furthest-cursor (cl-ecase direction
-                              (forwards  (mc/furthest-cursor-after-point))
-                              (backwards (mc/furthest-cursor-before-point)))))
-       (when (overlayp furthest-cursor)
-         (goto-char (overlay-get furthest-cursor 'point))
-         (when (= num-lines 0)
-           (mc/remove-fake-cursor furthest-cursor))))
-     (cl-ecase direction
-       (forwards (next-logical-line 1 nil))
-       (backwards (previous-logical-line 1 nil)))
-     (mc/create-fake-cursor-at-point))))
-
-;;;###autoload
-(defun mc/mark-next-lines (arg)
-  (interactive "p")
-  (mc/mark-lines arg 'forwards)
-  (mc/maybe-multiple-cursors-mode))
-
-;;;###autoload
-(defun mc/mark-previous-lines (arg)
-  (interactive "p")
-  (mc/mark-lines arg 'backwards)
-  (mc/maybe-multiple-cursors-mode))
-
-;;;###autoload
-(defun mc/unmark-next-like-this ()
-  "Deselect next part of the buffer matching the currently active region."
-  (interactive)
-  (mc/mark-next-like-this -1))
-
-;;;###autoload
-(defun mc/unmark-previous-like-this ()
-  "Deselect prev part of the buffer matching the currently active region."
-  (interactive)
-  (mc/mark-previous-like-this -1))
-
-;;;###autoload
-(defun mc/skip-to-next-like-this ()
-  "Skip the current one and select the next part of the buffer matching the currently active region."
-  (interactive)
-  (mc/mark-next-like-this 0))
-
-;;;###autoload
-(defun mc/skip-to-previous-like-this ()
-  "Skip the current one and select the prev part of the buffer matching the currently active region."
-  (interactive)
-  (mc/mark-previous-like-this 0))
-
-;;;###autoload
-(defun mc/mark-all-like-this ()
-  "Find and mark all the parts of the buffer matching the currently active region"
-  (interactive)
-  (unless (region-active-p)
-    (error "Mark a region to match first."))
-  (mc/remove-fake-cursors)
-  (let ((master (point))
-        (case-fold-search nil)
-        (point-first (< (point) (mark)))
-        (re (regexp-opt (mc/region-strings) mc/enclose-search-term)))
-    (mc/save-excursion
-     (goto-char 0)
-     (while (search-forward-regexp re nil t)
-       (push-mark (match-beginning 0))
-       (when point-first (exchange-point-and-mark))
-       (unless (= master (point))
-         (mc/create-fake-cursor-at-point))
-       (when point-first (exchange-point-and-mark)))))
-  (if (> (mc/num-cursors) 1)
-      (multiple-cursors-mode 1)
-    (multiple-cursors-mode 0)))
-
-(defun mc--select-thing-at-point (thing)
-  (let ((bound (bounds-of-thing-at-point thing)))
-    (when bound
-      (set-mark (car bound))
-      (goto-char (cdr bound))
-      bound)))
-
-(defun mc--select-thing-at-point-or-bark (thing)
-  (unless (or (region-active-p) (mc--select-thing-at-point thing))
-    (error "Mark a region or set cursor on a %s." thing)))
-
-;;;###autoload
-(defun mc/mark-all-words-like-this ()
-  (interactive)
-  (mc--select-thing-at-point-or-bark 'word)
-  (let ((mc/enclose-search-term 'words))
-    (mc/mark-all-like-this)))
-
-;;;###autoload
-(defun mc/mark-all-symbols-like-this ()
-  (interactive)
-  (mc--select-thing-at-point-or-bark 'symbol)
-  (let ((mc/enclose-search-term 'symbols))
-    (mc/mark-all-like-this)))
-
-;;;###autoload
-(defun mc/mark-all-in-region (beg end &optional search)
-  "Find and mark all the parts in the region matching the given search"
-  (interactive "r")
-  (let ((search (or search (read-from-minibuffer "Mark all in region: ")))
-        (case-fold-search nil))
-    (if (string= search "")
-        (message "Mark aborted")
-      (progn
-        (mc/remove-fake-cursors)
-        (goto-char beg)
-        (while (search-forward search end t)
-          (push-mark (match-beginning 0))
-          (mc/create-fake-cursor-at-point))
-        (let ((first (mc/furthest-cursor-before-point)))
-          (if (not first)
-              (error "Search failed for %S" search)
-            (mc/pop-state-from-overlay first)))
-        (if (> (mc/num-cursors) 1)
-            (multiple-cursors-mode 1)
-          (multiple-cursors-mode 0))))))
-
-;;;###autoload
-(defun mc/mark-all-in-region-regexp (beg end)
-  "Find and mark all the parts in the region matching the given regexp."
-  (interactive "r")
-  (let ((search (read-regexp "Mark regexp in region: "))
-        (case-fold-search nil))
-    (if (string= search "")
-        (message "Mark aborted")
-      (progn
-        (mc/remove-fake-cursors)
-        (goto-char beg)
-        (let ((lastmatch))
-          (while (and (< (point) end) ; can happen because of (forward-char)
-                      (search-forward-regexp search end t))
-            (push-mark (match-beginning 0))
-            (mc/create-fake-cursor-at-point)
-            (setq lastmatch (point))
-            (when (= (point) (match-beginning 0))
-              (forward-char)))
-          (unless lastmatch
-            (error "Search failed for %S" search)))
-        (goto-char (match-end 0))
-        (if (< (mc/num-cursors) 3)
-            (multiple-cursors-mode 0)
-          (mc/pop-state-from-overlay (mc/furthest-cursor-before-point))
-          (multiple-cursors-mode 1))))))
-
-(when (not (fboundp 'set-temporary-overlay-map))
-  ;; Backport this function from newer emacs versions
-  (defun set-temporary-overlay-map (map &optional keep-pred)
-    "Set a new keymap that will only exist for a short period of time.
-The new keymap to use must be given in the MAP variable. When to
-remove the keymap depends on user input and KEEP-PRED:
-
-- if KEEP-PRED is nil (the default), the keymap disappears as
-  soon as any key is pressed, whether or not the key is in MAP;
-
-- if KEEP-PRED is t, the keymap disappears as soon as a key *not*
-  in MAP is pressed;
-
-- otherwise, KEEP-PRED must be a 0-arguments predicate that will
-  decide if the keymap should be removed (if predicate returns
-  nil) or kept (otherwise). The predicate will be called after
-  each key sequence."
-
-    (let* ((clearfunsym (make-symbol "clear-temporary-overlay-map"))
-           (overlaysym (make-symbol "t"))
-           (alist (list (cons overlaysym map)))
-           (clearfun
-            `(lambda ()
-               (unless ,(cond ((null keep-pred) nil)
-                              ((eq t keep-pred)
-                               `(eq this-command
-                                    (lookup-key ',map
-                                                (this-command-keys-vector))))
-                              (t `(funcall ',keep-pred)))
-                 (remove-hook 'pre-command-hook ',clearfunsym)
-                 (setq emulation-mode-map-alists
-                       (delq ',alist emulation-mode-map-alists))))))
-      (set overlaysym overlaysym)
-      (fset clearfunsym clearfun)
-      (add-hook 'pre-command-hook clearfunsym)
-
-      (push alist emulation-mode-map-alists))))
-
-;;;###autoload
-(defun mc/mark-more-like-this-extended ()
-  "Like mark-more-like-this, but then lets you adjust with arrows key.
-The adjustments work like this:
-
-   <up>    Mark previous like this and set direction to 'up
-   <down>  Mark next like this and set direction to 'down
-
-If direction is 'up:
-
-   <left>  Skip past the cursor furthest up
-   <right> Remove the cursor furthest up
-
-If direction is 'down:
-
-   <left>  Remove the cursor furthest down
-   <right> Skip past the cursor furthest down
-
-The bindings for these commands can be changed. See `mc/mark-more-like-this-extended-keymap'."
-  (interactive)
-  (mc/mmlte--down)
-  (set-temporary-overlay-map mc/mark-more-like-this-extended-keymap t))
-
-(defvar mc/mark-more-like-this-extended-direction nil
-  "When using mc/mark-more-like-this-extended are we working on the next or previous cursors?")
-
-(make-variable-buffer-local 'mc/mark-more-like-this-extended)
-
-(defun mc/mmlte--message ()
-  (if (eq mc/mark-more-like-this-extended-direction 'up)
-      (message "<up> to mark previous, <left> to skip, <right> to remove, <down> to mark next")
-    (message "<down> to mark next, <right> to skip, <left> to remove, <up> to mark previous")))
-
-(defun mc/mmlte--up ()
-  (interactive)
-  (mc/mark-previous-like-this 1)
-  (setq mc/mark-more-like-this-extended-direction 'up)
-  (mc/mmlte--message))
-
-(defun mc/mmlte--down ()
-  (interactive)
-  (mc/mark-next-like-this 1)
-  (setq mc/mark-more-like-this-extended-direction 'down)
-  (mc/mmlte--message))
-
-(defun mc/mmlte--left ()
-  (interactive)
-  (if (eq mc/mark-more-like-this-extended-direction 'down)
-      (mc/unmark-next-like-this)
-    (mc/skip-to-previous-like-this))
-  (mc/mmlte--message))
-
-(defun mc/mmlte--right ()
-  (interactive)
-  (if (eq mc/mark-more-like-this-extended-direction 'up)
-      (mc/unmark-previous-like-this)
-    (mc/skip-to-next-like-this))
-  (mc/mmlte--message))
-
-(defvar mc/mark-more-like-this-extended-keymap (make-sparse-keymap))
-
-(define-key mc/mark-more-like-this-extended-keymap (kbd "<up>") 'mc/mmlte--up)
-(define-key mc/mark-more-like-this-extended-keymap (kbd "<down>") 'mc/mmlte--down)
-(define-key mc/mark-more-like-this-extended-keymap (kbd "<left>") 'mc/mmlte--left)
-(define-key mc/mark-more-like-this-extended-keymap (kbd "<right>") 'mc/mmlte--right)
-
-(defvar mc--restrict-mark-all-to-symbols nil)
-
-;;;###autoload
-(defun mc/mark-all-like-this-dwim (arg)
-  "Tries to guess what you want to mark all of.
-Can be pressed multiple times to increase selection.
-
-With prefix, it behaves the same as original `mc/mark-all-like-this'"
-  (interactive "P")
-  (if arg
-      (mc/mark-all-like-this)
-    (if (and (not (use-region-p))
-             (derived-mode-p 'sgml-mode)
-             (mc--on-tag-name-p))
-        (mc/mark-sgml-tag-pair)
-      (let ((before (mc/num-cursors)))
-        (unless (eq last-command 'mc/mark-all-like-this-dwim)
-          (setq mc--restrict-mark-all-to-symbols nil))
-        (unless (use-region-p)
-          (mc--mark-symbol-at-point)
-          (setq mc--restrict-mark-all-to-symbols t))
-        (if mc--restrict-mark-all-to-symbols
-            (mc/mark-all-symbols-like-this-in-defun)
-          (mc/mark-all-like-this-in-defun))
-        (when (<= (mc/num-cursors) before)
-          (if mc--restrict-mark-all-to-symbols
-              (mc/mark-all-symbols-like-this)
-            (mc/mark-all-like-this)))
-        (when (<= (mc/num-cursors) before)
-          (mc/mark-all-like-this))))))
-
-;;;###autoload
-(defun mc/mark-all-dwim (arg)
-  "Tries even harder to guess what you want to mark all of.
-
-If the region is active and spans multiple lines, it will behave
-as if `mc/mark-all-in-region'. With the prefix ARG, it will call
-`mc/edit-lines' instead.
-
-If the region is inactive or on a single line, it will behave like
-`mc/mark-all-like-this-dwim'."
-  (interactive "P")
-  (if (and (use-region-p)
-           (not (> (mc/num-cursors) 1))
-           (not (= (mc/line-number-at-pos (region-beginning))
-                   (mc/line-number-at-pos (region-end)))))
-      (if arg
-          (call-interactively 'mc/edit-lines)
-        (call-interactively 'mc/mark-all-in-region))
-    (progn
-      (setq this-command 'mc/mark-all-like-this-dwim)
-      (mc/mark-all-like-this-dwim arg))))
-
-(defun mc--in-defun ()
-  (bounds-of-thing-at-point 'defun))
-
-;;;###autoload
-(defun mc/mark-all-like-this-in-defun ()
-  "Mark all like this in defun."
-  (interactive)
-  (if (mc--in-defun)
-      (save-restriction
-        (widen)
-        (narrow-to-defun)
-        (mc/mark-all-like-this))
-    (mc/mark-all-like-this)))
-
-;;;###autoload
-(defun mc/mark-all-words-like-this-in-defun ()
-  "Mark all words like this in defun."
-  (interactive)
-  (mc--select-thing-at-point-or-bark 'word)
-  (if (mc--in-defun)
-      (save-restriction
-        (widen)
-        (narrow-to-defun)
-        (mc/mark-all-words-like-this))
-    (mc/mark-all-words-like-this)))
-
-;;;###autoload
-(defun mc/mark-all-symbols-like-this-in-defun ()
-  "Mark all symbols like this in defun."
-  (interactive)
-  (mc--select-thing-at-point-or-bark 'symbol)
-  (if (mc--in-defun)
-      (save-restriction
-        (widen)
-        (narrow-to-defun)
-        (mc/mark-all-symbols-like-this))
-    (mc/mark-all-symbols-like-this)))
-
-(defun mc--mark-symbol-at-point ()
-  "Select the symbol under cursor"
-  (interactive)
-  (when (not (use-region-p))
-    (let ((b (bounds-of-thing-at-point 'symbol)))
-      (goto-char (car b))
-      (set-mark (cdr b)))))
-
-(defun mc--get-nice-sgml-context ()
-  (car
-   (last
-    (progn
-      (when (looking-at "<") (forward-char 1))
-      (when (looking-back ">") (forward-char -1))
-      (sgml-get-context)))))
-
-(defun mc--on-tag-name-p ()
-  (let* ((context (save-excursion (mc--get-nice-sgml-context)))
-         (tag-name-len (length (aref context 4)))
-         (beg (aref context 2))
-         (end (+ beg tag-name-len (if (eq 'open (aref context 1)) 1 3))))
-    (and context
-         (>= (point) beg)
-         (<= (point) end))))
-
-;;;###autoload
-(defun mc/toggle-cursor-on-click (event)
-  "Add a cursor where you click, or remove a fake cursor that is
-already there."
-  (interactive "e")
-  (mouse-minibuffer-check event)
-  ;; Use event-end in case called from mouse-drag-region.
-  ;; If EVENT is a click, event-end and event-start give same value.
-  (let ((position (event-end event)))
-    (if (not (windowp (posn-window position)))
-        (error "Position not in text area of window"))
-    (select-window (posn-window position))
-    (let ((pt (posn-point position)))
-      (if (numberp pt)
-          ;; is there a fake cursor with the actual *point* right where we are?
-          (let ((existing (mc/fake-cursor-at-point pt)))
-            (if existing
-                (mc/remove-fake-cursor existing)
-              (save-excursion
-                (goto-char pt)
-                (mc/create-fake-cursor-at-point))))))
-    (mc/maybe-multiple-cursors-mode)))
-
-;;;###autoload
-(defalias 'mc/add-cursor-on-click 'mc/toggle-cursor-on-click)
-
-;;;###autoload
-(defun mc/mark-sgml-tag-pair ()
-  "Mark the tag we're in and its pair for renaming."
-  (interactive)
-  (when (not (mc--inside-tag-p))
-    (error "Place point inside tag to rename."))
-  (let ((context (mc--get-nice-sgml-context)))
-    (if (looking-at "</")
-        (setq context (car (last (sgml-get-context)))))
-    (goto-char (aref context 2))
-    (let* ((tag-name (aref context 4))
-           (num-chars (length tag-name))
-           (master-start (1+ (point)))
-           (mirror-end (save-excursion
-                         (sgml-skip-tag-forward 1)
-                         (1- (point)))))
-      (goto-char (- mirror-end num-chars))
-      (set-mark mirror-end)
-      (mc/create-fake-cursor-at-point)
-      (goto-char master-start)
-      (set-mark (+ (point) num-chars))))
-  (mc/maybe-multiple-cursors-mode))
-
-(defun mc--inside-tag-p ()
-  (save-excursion
-    (not (null (sgml-get-context)))))
-
-(provide 'mc-mark-more)
-
-;;; mc-mark-more.el ends here
diff --git a/elpa/multiple-cursors-20191210.1759/mc-mark-more.elc b/elpa/multiple-cursors-20191210.1759/mc-mark-more.elc
deleted file mode 100644
index cc8cbda1..00000000
Binary files a/elpa/multiple-cursors-20191210.1759/mc-mark-more.elc and /dev/null differ
diff --git a/elpa/multiple-cursors-20191210.1759/mc-mark-pop.el b/elpa/multiple-cursors-20191210.1759/mc-mark-pop.el
deleted file mode 100644
index 8a183812..00000000
--- a/elpa/multiple-cursors-20191210.1759/mc-mark-pop.el
+++ /dev/null
@@ -1,22 +0,0 @@
-;;; mc-mark-pop.el --- Pop cursors off of the mark stack
-
-(require 'multiple-cursors-core)
-
-;;;###autoload
-(defun mc/mark-pop ()
-  "Add a cursor at the current point, pop off mark ring and jump
-to the popped mark."
-  (interactive)
-  ;; If the mark happens to be at the current point, just pop that one off.
-  (while (eql (mark) (point))
-    (pop-mark))
-  (mc/create-fake-cursor-at-point)
-  (exchange-point-and-mark)
-  (pop-mark)
-  (mc/maybe-multiple-cursors-mode))
-
-;; A good key binding for this feature is perhaps "C-S-p" ('p' for pop).
-
-(provide 'mc-mark-pop)
-
-;;; mc-mark-pop.el ends here
diff --git a/elpa/multiple-cursors-20191210.1759/mc-mark-pop.elc b/elpa/multiple-cursors-20191210.1759/mc-mark-pop.elc
deleted file mode 100644
index 82a1d946..00000000
Binary files a/elpa/multiple-cursors-20191210.1759/mc-mark-pop.elc and /dev/null differ
diff --git a/elpa/multiple-cursors-20191210.1759/mc-separate-operations.el b/elpa/multiple-cursors-20191210.1759/mc-separate-operations.el
deleted file mode 100644
index f123ccaa..00000000
--- a/elpa/multiple-cursors-20191210.1759/mc-separate-operations.el
+++ /dev/null
@@ -1,150 +0,0 @@
-;;; mc-separate-operations.el - functions that work differently on each cursor
-
-;; Copyright (C) 2012-2016 Magnar Sveen
-
-;; Author: Magnar Sveen <magnars@gmail.com>
-;; Keywords: editing cursors
-
-;; This program is free software; you can redistribute it and/or modify
-;; it under the terms of the GNU General Public License as published by
-;; the Free Software Foundation, either version 3 of the License, or
-;; (at your option) any later version.
-
-;; This program is distributed in the hope that it will be useful,
-;; but WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-;; GNU General Public License for more details.
-
-;; You should have received a copy of the GNU General Public License
-;; along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-;;; Commentary:
-
-;; This file contains functions that work differently on each cursor,
-;; instead of treating all of them the same.
-
-;; Please see multiple-cursors.el for more commentary.
-
-;;; Code:
-
-(require 'multiple-cursors-core)
-
-(defcustom mc/insert-numbers-default 0
-  "The default number at which to start counting for
-`mc/insert-numbers'"
-  :type 'integer
-  :group 'multiple-cursors)
-
-(defvar mc--insert-numbers-number 0)
-
-;;;###autoload
-(defun mc/insert-numbers (arg)
-  "Insert increasing numbers for each cursor, starting at
-`mc/insert-numbers-default' or ARG."
-  (interactive "P")
-  (setq mc--insert-numbers-number (or (and arg (prefix-numeric-value arg))
-                                      mc/insert-numbers-default))
-  (mc/for-each-cursor-ordered
-   (mc/execute-command-for-fake-cursor 'mc--insert-number-and-increase cursor)))
-
-(defun mc--insert-number-and-increase ()
-  (interactive)
-  (insert (number-to-string mc--insert-numbers-number))
-  (setq mc--insert-numbers-number (1+ mc--insert-numbers-number)))
-
-(defun mc--ordered-region-strings ()
-  (let (strings)
-    (save-excursion
-      (mc/for-each-cursor-ordered
-       (setq strings (cons (buffer-substring-no-properties
-                            (mc/cursor-beg cursor)
-                            (mc/cursor-end cursor)) strings))))
-    (nreverse strings)))
-
-(defvar mc--insert-letters-number 0)
-
-;;;###autoload
-(defun mc/insert-letters (arg)
-  "Insert increasing letters for each cursor, starting at 0 or ARG.
-     Where letter[0]=a letter[2]=c letter[26]=aa"
-  (interactive "P")
-  (setq mc--insert-letters-number (or (and arg (prefix-numeric-value arg))
-                                      0))
-  (mc/for-each-cursor-ordered
-   (mc/execute-command-for-fake-cursor 'mc--insert-letter-and-increase cursor)))
-
-(defun mc--number-to-letters (number)
-  (let ((letter
-         (char-to-string
-          (+ (mod number 26) ?a)))
-        (number2 (/ number 26)))
-    (if (> number2 0)
-        (concat (mc--number-to-letters (- number2 1)) letter)
-      letter)))
-
-(defun mc--insert-letter-and-increase ()
-  (interactive)
-  (insert (mc--number-to-letters mc--insert-letters-number))
-  (setq mc--insert-letters-number (1+ mc--insert-letters-number)))
-
-(defvar mc--strings-to-replace nil)
-
-(defun mc--replace-region-strings-1 ()
-  (interactive)
-  (delete-region (region-beginning) (region-end))
-  (save-excursion (insert (car mc--strings-to-replace)))
-  (setq mc--strings-to-replace (cdr mc--strings-to-replace)))
-
-(defun mc--replace-region-strings ()
-  (mc/for-each-cursor-ordered
-   (mc/execute-command-for-fake-cursor 'mc--replace-region-strings-1 cursor)))
-
-;;;###autoload
-(defun mc/reverse-regions ()
-  (interactive)
-  (if (not multiple-cursors-mode)
-      (progn
-        (mc/mark-next-lines 1)
-        (mc/reverse-regions)
-        (multiple-cursors-mode 0))
-    (unless (use-region-p)
-      (mc/execute-command-for-all-cursors 'mark-sexp))
-    (setq mc--strings-to-replace (nreverse (mc--ordered-region-strings)))
-    (mc--replace-region-strings)))
-
-;;;###autoload
-(defun mc/sort-regions ()
-  (interactive)
-  (unless (use-region-p)
-    (mc/execute-command-for-all-cursors 'mark-sexp))
-  (setq mc--strings-to-replace (sort (mc--ordered-region-strings) 'string<))
-  (mc--replace-region-strings))
-
-
-;;;###autoload
-(defun mc/vertical-align (character)
-  "Aligns all cursors vertically with a given CHARACTER to the one with the
-highest column number (the rightest).
-Might not behave as intended if more than one cursors are on the same line."
-  (interactive "c")
-  (let ((rightest-column (current-column)))
-    (mc/execute-command-for-all-cursors
-     (lambda () "get the rightest cursor"
-       (interactive)
-       (setq rightest-column (max (current-column) rightest-column))
-       ))
-    (mc/execute-command-for-all-cursors
-     (lambda ()
-       (interactive)
-       (let ((missing-spaces (- rightest-column (current-column))))
-         (save-excursion (insert (make-string missing-spaces character)))
-         (forward-char missing-spaces))))))
-
-;;;###autoload
-(defun mc/vertical-align-with-space ()
-  "Aligns all cursors with whitespace like `mc/vertical-align' does"
-  (interactive)
-  (mc/vertical-align 32))
-
-(provide 'mc-separate-operations)
-;;; mc-separate-operations.el ends here
diff --git a/elpa/multiple-cursors-20191210.1759/mc-separate-operations.elc b/elpa/multiple-cursors-20191210.1759/mc-separate-operations.elc
deleted file mode 100644
index 6f60bbf4..00000000
Binary files a/elpa/multiple-cursors-20191210.1759/mc-separate-operations.elc and /dev/null differ
diff --git a/elpa/multiple-cursors-20191210.1759/multiple-cursors-autoloads.el b/elpa/multiple-cursors-20191210.1759/multiple-cursors-autoloads.el
deleted file mode 100644
index 1ddb851c..00000000
--- a/elpa/multiple-cursors-20191210.1759/multiple-cursors-autoloads.el
+++ /dev/null
@@ -1,362 +0,0 @@
-;;; multiple-cursors-autoloads.el --- automatically extracted autoloads
-;;
-;;; Code:
-
-(add-to-list 'load-path (directory-file-name
-                         (or (file-name-directory #$) (car load-path))))
-
-
-;;;### (autoloads nil "mc-cycle-cursors" "mc-cycle-cursors.el" (0
-;;;;;;  0 0 0))
-;;; Generated autoloads from mc-cycle-cursors.el
-
-(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "mc-cycle-cursors" '("mc/")))
-
-;;;***
-
-;;;### (autoloads nil "mc-edit-lines" "mc-edit-lines.el" (0 0 0 0))
-;;; Generated autoloads from mc-edit-lines.el
-
-(autoload 'mc/edit-lines "mc-edit-lines" "\
-Add one cursor to each line of the active region.
-Starts from mark and moves in straight down or up towards the
-line point is on.
-
-What is done with lines which are not long enough is governed by
-`mc/edit-lines-empty-lines'.  The prefix argument ARG can be used
-to override this.  If ARG is a symbol (when called from Lisp),
-that symbol is used instead of `mc/edit-lines-empty-lines'.
-Otherwise, if ARG negative, short lines will be ignored.  Any
-other non-nil value will cause short lines to be padded.
-
-\(fn &optional ARG)" t nil)
-
-(autoload 'mc/edit-ends-of-lines "mc-edit-lines" "\
-Add one cursor to the end of each line in the active region.
-
-\(fn)" t nil)
-
-(autoload 'mc/edit-beginnings-of-lines "mc-edit-lines" "\
-Add one cursor to the beginning of each line in the active region.
-
-\(fn)" t nil)
-
-(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "mc-edit-lines" '("mc/edit-lines-empty-lines")))
-
-;;;***
-
-;;;### (autoloads nil "mc-hide-unmatched-lines-mode" "mc-hide-unmatched-lines-mode.el"
-;;;;;;  (0 0 0 0))
-;;; Generated autoloads from mc-hide-unmatched-lines-mode.el
-
-(autoload 'mc-hide-unmatched-lines-mode "mc-hide-unmatched-lines-mode" "\
-Minor mode when enabled hides all lines where no cursors (and
-also hum/lines-to-expand below and above) To make use of this
-mode press \"C-'\" while multiple-cursor-mode is active. You can
-still edit lines while you are in mc-hide-unmatched-lines
-mode. To leave this mode press <return> or \"C-g\"
-
-\(fn &optional ARG)" t nil)
-
-(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "mc-hide-unmatched-lines-mode" '("hum/")))
-
-;;;***
-
-;;;### (autoloads nil "mc-mark-more" "mc-mark-more.el" (0 0 0 0))
-;;; Generated autoloads from mc-mark-more.el
-
-(autoload 'mc/mark-next-like-this "mc-mark-more" "\
-Find and mark the next part of the buffer matching the currently active region
-If no region is active add a cursor on the next line
-With negative ARG, delete the last one instead.
-With zero ARG, skip the last one and mark next.
-
-\(fn ARG)" t nil)
-
-(autoload 'mc/mark-next-like-this-word "mc-mark-more" "\
-Find and mark the next part of the buffer matching the currently active region
-If no region is active, mark the word at the point and find the next match
-With negative ARG, delete the last one instead.
-With zero ARG, skip the last one and mark next.
-
-\(fn ARG)" t nil)
-
-(autoload 'mc/mark-next-word-like-this "mc-mark-more" "\
-Find and mark the next word of the buffer matching the currently active region
-The matching region must be a whole word to be a match
-If no region is active, mark the symbol at the point and find the next match
-With negative ARG, delete the last one instead.
-With zero ARG, skip the last one and mark next.
-
-\(fn ARG)" t nil)
-
-(autoload 'mc/mark-next-symbol-like-this "mc-mark-more" "\
-Find and mark the next symbol of the buffer matching the currently active region
-The matching region must be a whole symbol to be a match
-If no region is active, mark the symbol at the point and find the next match
-With negative ARG, delete the last one instead.
-With zero ARG, skip the last one and mark next.
-
-\(fn ARG)" t nil)
-
-(autoload 'mc/mark-previous-like-this "mc-mark-more" "\
-Find and mark the previous part of the buffer matching the currently active region
-If no region is active add a cursor on the previous line
-With negative ARG, delete the last one instead.
-With zero ARG, skip the last one and mark next.
-
-\(fn ARG)" t nil)
-
-(autoload 'mc/mark-previous-like-this-word "mc-mark-more" "\
-Find and mark the previous part of the buffer matching the currently active region
-If no region is active, mark the word at the point and find the previous match
-With negative ARG, delete the last one instead.
-With zero ARG, skip the last one and mark previous.
-
-\(fn ARG)" t nil)
-
-(autoload 'mc/mark-previous-word-like-this "mc-mark-more" "\
-Find and mark the previous part of the buffer matching the currently active region
-The matching region must be a whole word to be a match
-If no region is active add a cursor on the previous line
-With negative ARG, delete the last one instead.
-With zero ARG, skip the last one and mark next.
-
-\(fn ARG)" t nil)
-
-(autoload 'mc/mark-previous-symbol-like-this "mc-mark-more" "\
-Find and mark the previous part of the buffer matching the currently active region
-The matching region must be a whole symbol to be a match
-If no region is active add a cursor on the previous line
-With negative ARG, delete the last one instead.
-With zero ARG, skip the last one and mark next.
-
-\(fn ARG)" t nil)
-
-(autoload 'mc/mark-next-lines "mc-mark-more" "\
-
-
-\(fn ARG)" t nil)
-
-(autoload 'mc/mark-previous-lines "mc-mark-more" "\
-
-
-\(fn ARG)" t nil)
-
-(autoload 'mc/unmark-next-like-this "mc-mark-more" "\
-Deselect next part of the buffer matching the currently active region.
-
-\(fn)" t nil)
-
-(autoload 'mc/unmark-previous-like-this "mc-mark-more" "\
-Deselect prev part of the buffer matching the currently active region.
-
-\(fn)" t nil)
-
-(autoload 'mc/skip-to-next-like-this "mc-mark-more" "\
-Skip the current one and select the next part of the buffer matching the currently active region.
-
-\(fn)" t nil)
-
-(autoload 'mc/skip-to-previous-like-this "mc-mark-more" "\
-Skip the current one and select the prev part of the buffer matching the currently active region.
-
-\(fn)" t nil)
-
-(autoload 'mc/mark-all-like-this "mc-mark-more" "\
-Find and mark all the parts of the buffer matching the currently active region
-
-\(fn)" t nil)
-
-(autoload 'mc/mark-all-words-like-this "mc-mark-more" "\
-
-
-\(fn)" t nil)
-
-(autoload 'mc/mark-all-symbols-like-this "mc-mark-more" "\
-
-
-\(fn)" t nil)
-
-(autoload 'mc/mark-all-in-region "mc-mark-more" "\
-Find and mark all the parts in the region matching the given search
-
-\(fn BEG END &optional SEARCH)" t nil)
-
-(autoload 'mc/mark-all-in-region-regexp "mc-mark-more" "\
-Find and mark all the parts in the region matching the given regexp.
-
-\(fn BEG END)" t nil)
-
-(autoload 'mc/mark-more-like-this-extended "mc-mark-more" "\
-Like mark-more-like-this, but then lets you adjust with arrows key.
-The adjustments work like this:
-
-   <up>    Mark previous like this and set direction to 'up
-   <down>  Mark next like this and set direction to 'down
-
-If direction is 'up:
-
-   <left>  Skip past the cursor furthest up
-   <right> Remove the cursor furthest up
-
-If direction is 'down:
-
-   <left>  Remove the cursor furthest down
-   <right> Skip past the cursor furthest down
-
-The bindings for these commands can be changed. See `mc/mark-more-like-this-extended-keymap'.
-
-\(fn)" t nil)
-
-(autoload 'mc/mark-all-like-this-dwim "mc-mark-more" "\
-Tries to guess what you want to mark all of.
-Can be pressed multiple times to increase selection.
-
-With prefix, it behaves the same as original `mc/mark-all-like-this'
-
-\(fn ARG)" t nil)
-
-(autoload 'mc/mark-all-dwim "mc-mark-more" "\
-Tries even harder to guess what you want to mark all of.
-
-If the region is active and spans multiple lines, it will behave
-as if `mc/mark-all-in-region'. With the prefix ARG, it will call
-`mc/edit-lines' instead.
-
-If the region is inactive or on a single line, it will behave like
-`mc/mark-all-like-this-dwim'.
-
-\(fn ARG)" t nil)
-
-(autoload 'mc/mark-all-like-this-in-defun "mc-mark-more" "\
-Mark all like this in defun.
-
-\(fn)" t nil)
-
-(autoload 'mc/mark-all-words-like-this-in-defun "mc-mark-more" "\
-Mark all words like this in defun.
-
-\(fn)" t nil)
-
-(autoload 'mc/mark-all-symbols-like-this-in-defun "mc-mark-more" "\
-Mark all symbols like this in defun.
-
-\(fn)" t nil)
-
-(autoload 'mc/toggle-cursor-on-click "mc-mark-more" "\
-Add a cursor where you click, or remove a fake cursor that is
-already there.
-
-\(fn EVENT)" t nil)
-
-(defalias 'mc/add-cursor-on-click 'mc/toggle-cursor-on-click)
-
-(autoload 'mc/mark-sgml-tag-pair "mc-mark-more" "\
-Mark the tag we're in and its pair for renaming.
-
-\(fn)" t nil)
-
-(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "mc-mark-more" '("mc/" "mc--")))
-
-;;;***
-
-;;;### (autoloads nil "mc-mark-pop" "mc-mark-pop.el" (0 0 0 0))
-;;; Generated autoloads from mc-mark-pop.el
-
-(autoload 'mc/mark-pop "mc-mark-pop" "\
-Add a cursor at the current point, pop off mark ring and jump
-to the popped mark.
-
-\(fn)" t nil)
-
-;;;***
-
-;;;### (autoloads nil "mc-separate-operations" "mc-separate-operations.el"
-;;;;;;  (0 0 0 0))
-;;; Generated autoloads from mc-separate-operations.el
-
-(autoload 'mc/insert-numbers "mc-separate-operations" "\
-Insert increasing numbers for each cursor, starting at
-`mc/insert-numbers-default' or ARG.
-
-\(fn ARG)" t nil)
-
-(autoload 'mc/insert-letters "mc-separate-operations" "\
-Insert increasing letters for each cursor, starting at 0 or ARG.
-     Where letter[0]=a letter[2]=c letter[26]=aa
-
-\(fn ARG)" t nil)
-
-(autoload 'mc/reverse-regions "mc-separate-operations" "\
-
-
-\(fn)" t nil)
-
-(autoload 'mc/sort-regions "mc-separate-operations" "\
-
-
-\(fn)" t nil)
-
-(autoload 'mc/vertical-align "mc-separate-operations" "\
-Aligns all cursors vertically with a given CHARACTER to the one with the
-highest column number (the rightest).
-Might not behave as intended if more than one cursors are on the same line.
-
-\(fn CHARACTER)" t nil)
-
-(autoload 'mc/vertical-align-with-space "mc-separate-operations" "\
-Aligns all cursors with whitespace like `mc/vertical-align' does
-
-\(fn)" t nil)
-
-(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "mc-separate-operations" '("mc/insert-numbers-default" "mc--")))
-
-;;;***
-
-;;;### (autoloads nil "multiple-cursors-core" "multiple-cursors-core.el"
-;;;;;;  (0 0 0 0))
-;;; Generated autoloads from multiple-cursors-core.el
-
-(autoload 'multiple-cursors-mode "multiple-cursors-core" "\
-Mode while multiple cursors are active.
-
-\(fn &optional ARG)" t nil)
-
-(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "multiple-cursors-core" '("multiple-cursors-mode" "unsupported-cmd" "deactivate-cursor-after-undo" "activate-cursor-for-undo")))
-
-;;;***
-
-;;;### (autoloads nil "rectangular-region-mode" "rectangular-region-mode.el"
-;;;;;;  (0 0 0 0))
-;;; Generated autoloads from rectangular-region-mode.el
-
-(autoload 'set-rectangular-region-anchor "rectangular-region-mode" "\
-Anchors the rectangular region at point.
-
-Think of this one as `set-mark' except you're marking a rectangular region. It is
-an exceedingly quick way of adding multiple cursors to multiple lines.
-
-\(fn)" t nil)
-
-(autoload 'rectangular-region-mode "rectangular-region-mode" "\
-A mode for creating a rectangular region to edit
-
-\(fn &optional ARG)" t nil)
-
-(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "rectangular-region-mode" '("rectangular-region-mode" "rrm/")))
-
-;;;***
-
-;;;### (autoloads nil nil ("multiple-cursors-pkg.el" "multiple-cursors.el")
-;;;;;;  (0 0 0 0))
-
-;;;***
-
-;; Local Variables:
-;; version-control: never
-;; no-byte-compile: t
-;; no-update-autoloads: t
-;; coding: utf-8
-;; End:
-;;; multiple-cursors-autoloads.el ends here
diff --git a/elpa/multiple-cursors-20191210.1759/multiple-cursors-core.el b/elpa/multiple-cursors-20191210.1759/multiple-cursors-core.el
deleted file mode 100644
index 5d8cb8a6..00000000
--- a/elpa/multiple-cursors-20191210.1759/multiple-cursors-core.el
+++ /dev/null
@@ -1,852 +0,0 @@
-;;; multiple-cursors-core.el --- An experiment in multiple cursors for emacs.
-
-;; Copyright (C) 2012-2016 Magnar Sveen
-
-;; Author: Magnar Sveen <magnars@gmail.com>
-;; Keywords: editing cursors
-
-;; This program is free software; you can redistribute it and/or modify
-;; it under the terms of the GNU General Public License as published by
-;; the Free Software Foundation, either version 3 of the License, or
-;; (at your option) any later version.
-
-;; This program is distributed in the hope that it will be useful,
-;; but WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-;; GNU General Public License for more details.
-
-;; You should have received a copy of the GNU General Public License
-;; along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-;;; Commentary:
-
-;; This file contains the core functionality of multiple-cursors.
-;; Please see multiple-cursors.el for more commentary.
-
-;;; Code:
-
-(require 'cl-lib)
-(require 'rect)
-
-(defvar mc--read-char)
-
-(defface mc/cursor-face
-  '((t (:inverse-video t)))
-  "The face used for fake cursors"
-  :group 'multiple-cursors)
-
-(defface mc/cursor-bar-face
-  `((t (:height 1 :background ,(face-attribute 'cursor :background))))
-  "The face used for fake cursors if the cursor-type is bar"
-  :group 'multiple-cursors)
-
-(defface mc/region-face
-  '((t :inherit region))
-  "The face used for fake regions"
-  :group 'multiple-cursors)
-
-(defmacro mc/add-fake-cursor-to-undo-list (&rest forms)
-  "Make sure point is in the right place when undoing"
-  (let ((uc (make-symbol "undo-cleaner")))
-    `(let ((,uc (cons 'apply (cons 'deactivate-cursor-after-undo (list id)))))
-       (setq buffer-undo-list (cons ,uc buffer-undo-list))
-       ,@forms
-       (if (eq ,uc (car buffer-undo-list)) ;; if nothing has been added to the undo-list
-           (setq buffer-undo-list (cdr buffer-undo-list)) ;; then pop the cleaner right off again
-         (setq buffer-undo-list ;; otherwise add a function to activate this cursor
-               (cons (cons 'apply (cons 'activate-cursor-for-undo (list id))) buffer-undo-list))))))
-
-(defun mc/all-fake-cursors (&optional start end)
-  (cl-remove-if-not 'mc/fake-cursor-p
-                    (overlays-in (or start (point-min))
-                                 (or end   (point-max)))))
-
-(defmacro mc/for-each-fake-cursor (&rest forms)
-  "Runs the body for each fake cursor, bound to the name cursor"
-  `(mapc #'(lambda (cursor) ,@forms)
-         (mc/all-fake-cursors)))
-
-(defmacro mc/save-excursion (&rest forms)
-  "Saves and restores all the state that multiple-cursors cares about."
-  (let ((cs (make-symbol "current-state")))
-    `(let ((,cs (mc/store-current-state-in-overlay
-                 (make-overlay (point) (point) nil nil t))))
-       (overlay-put ,cs 'type 'original-cursor)
-       (save-excursion ,@forms)
-       (mc/pop-state-from-overlay ,cs))))
-
-(defun mc--compare-by-overlay-start (o1 o2)
-  (< (overlay-start o1) (overlay-start o2)))
-
-(defmacro mc/for-each-cursor-ordered (&rest forms)
-  "Runs the body for each cursor, fake and real, bound to the name cursor"
-  (let ((rci (make-symbol "real-cursor-id")))
-    `(let ((,rci (overlay-get (mc/create-fake-cursor-at-point) 'mc-id)))
-       (mapc #'(lambda (cursor)
-                 (when (mc/fake-cursor-p cursor)
-                   ,@forms))
-             (sort (overlays-in (point-min) (point-max)) 'mc--compare-by-overlay-start))
-       (mc/pop-state-from-overlay (mc/cursor-with-id ,rci)))))
-
-(defmacro mc/save-window-scroll (&rest forms)
-  "Saves and restores the window scroll position"
-  (let ((p (make-symbol "p"))
-        (s (make-symbol "start"))
-        (h (make-symbol "hscroll")))
-    `(let ((,p (set-marker (make-marker) (point)))
-           (,s (set-marker (make-marker) (window-start)))
-           (,h (window-hscroll)))
-       ,@forms
-       (goto-char ,p)
-       (set-window-start nil ,s t)
-       (set-window-hscroll nil ,h)
-       (set-marker ,p nil)
-       (set-marker ,s nil))))
-
-(defun mc/cursor-is-bar ()
-  "Return non-nil if the cursor is a bar."
-  (or (eq cursor-type 'bar)
-    (and (listp cursor-type)
-         (eq (car cursor-type) 'bar))))
-
-(defun mc/line-number-at-pos (&optional pos absolute)
-  "Faster implementation of `line-number-at-pos'."
-  (if pos
-      (save-excursion
-        (if absolute
-            (save-restriction
-              (widen)
-              (goto-char pos)
-              (string-to-number (format-mode-line "%l")))
-          (goto-char pos)
-          (string-to-number (format-mode-line "%l"))))
-    (string-to-number (format-mode-line "%l"))))
-
-(defun mc/make-cursor-overlay-at-eol (pos)
-  "Create overlay to look like cursor at end of line."
-  (let ((overlay (make-overlay pos pos nil nil nil)))
-    (if (mc/cursor-is-bar)
-	(overlay-put overlay 'before-string (propertize "|" 'face 'mc/cursor-bar-face))
-      (overlay-put overlay 'after-string (propertize " " 'face 'mc/cursor-face)))
-    overlay))
-
-(defun mc/make-cursor-overlay-inline (pos)
-  "Create overlay to look like cursor inside text."
-  (let ((overlay (make-overlay pos (1+ pos) nil nil nil)))
-    (if (mc/cursor-is-bar)
-	(overlay-put overlay 'before-string (propertize "|" 'face 'mc/cursor-bar-face))
-      (overlay-put overlay 'face 'mc/cursor-face))
-    overlay))
-
-(defun mc/make-cursor-overlay-at-point ()
-  "Create overlay to look like cursor.
-Special case for end of line, because overlay over a newline
-highlights the entire width of the window."
-  (if (eolp)
-      (mc/make-cursor-overlay-at-eol (point))
-    (mc/make-cursor-overlay-inline (point))))
-
-(defun mc/make-region-overlay-between-point-and-mark ()
-  "Create overlay to look like active region."
-  (let ((overlay (make-overlay (mark) (point) nil nil t)))
-    (overlay-put overlay 'face 'mc/region-face)
-    (overlay-put overlay 'type 'additional-region)
-    overlay))
-
-(defvar mc/cursor-specific-vars '(transient-mark-mode
-                                  kill-ring
-                                  kill-ring-yank-pointer
-                                  mark-ring
-                                  mark-active
-                                  yank-undo-function
-                                  autopair-action
-                                  autopair-wrap-action
-                                  temporary-goal-column
-                                  er/history
-                                  dabbrev--abbrev-char-regexp
-                                  dabbrev--check-other-buffers
-                                  dabbrev--friend-buffer-list
-                                  dabbrev--last-abbrev-location
-                                  dabbrev--last-abbreviation
-                                  dabbrev--last-buffer
-                                  dabbrev--last-buffer-found
-                                  dabbrev--last-direction
-                                  dabbrev--last-expansion
-                                  dabbrev--last-expansion-location
-                                  dabbrev--last-table)
-  "A list of vars that need to be tracked on a per-cursor basis.")
-
-(defun mc/store-current-state-in-overlay (o)
-  "Store relevant info about point and mark in the given overlay."
-  (overlay-put o 'point (set-marker (make-marker) (point)))
-  (overlay-put o 'mark (set-marker (make-marker)
-				   (let ((mark-even-if-inactive t))
-				     (mark))))
-  (dolist (var mc/cursor-specific-vars)
-    (when (boundp var) (overlay-put o var (symbol-value var))))
-  o)
-
-(defun mc/restore-state-from-overlay (o)
-  "Restore point and mark from stored info in the given overlay."
-  (goto-char (overlay-get o 'point))
-  (set-marker (mark-marker) (overlay-get o 'mark))
-  (dolist (var mc/cursor-specific-vars)
-    (when (boundp var) (set var (overlay-get o var)))))
-
-(defun mc/remove-fake-cursor (o)
-  "Delete overlay with state, including dependent overlays and markers."
-  (set-marker (overlay-get o 'point) nil)
-  (set-marker (overlay-get o 'mark) nil)
-  (mc/delete-region-overlay o)
-  (delete-overlay o))
-
-(defun mc/pop-state-from-overlay (o)
-  "Restore the state stored in given overlay and then remove the overlay."
-  (mc/restore-state-from-overlay o)
-  (mc/remove-fake-cursor o))
-
-(defun mc/delete-region-overlay (o)
-  "Remove the dependent region overlay for a given cursor overlay."
-  (ignore-errors
-    (delete-overlay (overlay-get o 'region-overlay))))
-
-(defvar mc--current-cursor-id 0
-  "Var to store increasing id of fake cursors, used to keep track of them for undo.")
-
-(defun mc/create-cursor-id ()
-  "Returns a unique cursor id"
-  (cl-incf mc--current-cursor-id))
-
-(defvar mc--max-cursors-original nil
-  "This variable maintains the original maximum number of cursors.
-When `mc/create-fake-cursor-at-point' is called and
-`mc/max-cursors' is overridden, this value serves as a backup so
-that `mc/max-cursors' can take on a new value.  When
-`mc/remove-fake-cursors' is called, the values are reset.")
-
-(defcustom mc/max-cursors nil
-  "Safety ceiling for the number of active cursors.
-If your emacs slows down or freezes when using too many cursors,
-customize this value appropriately.
-
-Cursors will be added until this value is reached, at which point
-you can either temporarily override the value or abort the
-operation entirely.
-
-If this value is nil, there is no ceiling."
-  :type '(integer)
-  :group 'multiple-cursors)
-
-(defun mc/create-fake-cursor-at-point (&optional id)
-  "Add a fake cursor and possibly a fake active region overlay based on point and mark.
-Saves the current state in the overlay to be restored later."
-  (unless mc--max-cursors-original
-    (setq mc--max-cursors-original mc/max-cursors))
-  (when mc/max-cursors
-    (unless (< (mc/num-cursors) mc/max-cursors)
-      (if (yes-or-no-p (format "%d active cursors. Continue? " (mc/num-cursors)))
-          (setq mc/max-cursors (read-number "Enter a new, temporary maximum: "))
-        (mc/remove-fake-cursors)
-        (error "Aborted: too many cursors"))))
-  (let ((overlay (mc/make-cursor-overlay-at-point)))
-    (overlay-put overlay 'mc-id (or id (mc/create-cursor-id)))
-    (overlay-put overlay 'type 'fake-cursor)
-    (overlay-put overlay 'priority 100)
-    (mc/store-current-state-in-overlay overlay)
-    (when (use-region-p)
-      (overlay-put overlay 'region-overlay
-                   (mc/make-region-overlay-between-point-and-mark)))
-    overlay))
-
-(defun mc/execute-command (cmd)
-  "Run command, simulating the parts of the command loop that makes sense for fake cursors."
-  (setq this-command cmd)
-  (run-hooks 'pre-command-hook)
-  (unless (eq this-command 'ignore)
-    (call-interactively cmd))
-  (run-hooks 'post-command-hook)
-  (when deactivate-mark (deactivate-mark)))
-
-(defvar mc--executing-command-for-fake-cursor nil)
-
-(defun mc/execute-command-for-fake-cursor (cmd cursor)
-  (let ((mc--executing-command-for-fake-cursor t)
-        (id (overlay-get cursor 'mc-id))
-        (annoying-arrows-mode nil)
-        (smooth-scroll-margin 0))
-    (mc/add-fake-cursor-to-undo-list
-     (mc/pop-state-from-overlay cursor)
-     (ignore-errors
-       (mc/execute-command cmd)
-       (mc/create-fake-cursor-at-point id)))))
-
-(defun mc/execute-command-for-all-fake-cursors (cmd)
-  "Calls CMD interactively for each cursor.
-It works by moving point to the fake cursor, setting
-up the proper environment, and then removing the cursor.
-After executing the command, it sets up a new fake
-cursor with updated info."
-  (mc/save-excursion
-   (mc/save-window-scroll
-    (mc/for-each-fake-cursor
-     (save-excursion
-       (mc/execute-command-for-fake-cursor cmd cursor)))))
-  (mc--reset-read-prompts))
-
-(defun mc/execute-command-for-all-cursors (cmd)
-  "Calls CMD interactively for the real cursor and all fakes."
-  (call-interactively cmd)
-  (mc/execute-command-for-all-fake-cursors cmd))
-
-;; Intercept some reading commands so you won't have to
-;; answer them for every single cursor
-
-(defvar mc--read-char nil)
-(defvar multiple-cursors-mode nil)
-(defadvice read-char (around mc-support activate)
-  (if (not multiple-cursors-mode)
-      ad-do-it
-    (unless mc--read-char
-      (setq mc--read-char ad-do-it))
-    (setq ad-return-value mc--read-char)))
-
-(defvar mc--read-quoted-char nil)
-(defadvice read-quoted-char (around mc-support activate)
-  (if (not multiple-cursors-mode)
-      ad-do-it
-    (unless mc--read-quoted-char
-      (setq mc--read-quoted-char ad-do-it))
-    (setq ad-return-value mc--read-quoted-char)))
-
-(defun mc--reset-read-prompts ()
-  (setq mc--read-char nil)
-  (setq mc--read-quoted-char nil))
-
-(mc--reset-read-prompts)
-
-(defun mc/fake-cursor-p (o)
-  "Predicate to check if an overlay is a fake cursor"
-  (eq (overlay-get o 'type) 'fake-cursor))
-
-(defun mc/cursor-with-id (id)
-  "Find the first cursor with the given id, or nil"
-  (cl-find-if #'(lambda (o) (and (mc/fake-cursor-p o)
-                            (= id (overlay-get o 'mc-id))))
-              (overlays-in (point-min) (point-max))))
-
-(defvar mc--stored-state-for-undo nil
-  "Variable to keep the state of the real cursor while undoing a fake one")
-
-(defun activate-cursor-for-undo (id)
-  "Called when undoing to temporarily activate the fake cursor which action is being undone."
-  (let ((cursor (mc/cursor-with-id id)))
-    (when cursor
-      (setq mc--stored-state-for-undo (mc/store-current-state-in-overlay
-                                       (make-overlay (point) (point) nil nil t)))
-      (mc/pop-state-from-overlay cursor))))
-
-(defun deactivate-cursor-after-undo (id)
-  "Called when undoing to reinstate the real cursor after undoing a fake one."
-  (when mc--stored-state-for-undo
-    (mc/create-fake-cursor-at-point id)
-    (mc/pop-state-from-overlay mc--stored-state-for-undo)
-    (setq mc--stored-state-for-undo nil)))
-
-(defcustom mc/always-run-for-all nil
-  "Disables whitelisting and always executes commands for every fake cursor."
-  :type '(boolean)
-  :group 'multiple-cursors)
-
-(defcustom mc/always-repeat-command nil
-  "Disables confirmation for `mc/repeat-command' command."
-  :type '(boolean)
-  :group 'multiple-cursors)
-
-(defun mc/prompt-for-inclusion-in-whitelist (original-command)
-  "Asks the user, then adds the command either to the once-list or the all-list."
-  (let ((all-p (y-or-n-p (format "Do %S for all cursors?" original-command))))
-    (if all-p
-        (add-to-list 'mc/cmds-to-run-for-all original-command)
-      (add-to-list 'mc/cmds-to-run-once original-command))
-    (mc/save-lists)
-    all-p))
-
-(defun mc/num-cursors ()
-  "The number of cursors (real and fake) in the buffer."
-  (1+ (cl-count-if 'mc/fake-cursor-p
-                   (overlays-in (point-min) (point-max)))))
-
-(defvar mc--this-command nil
-  "Used to store the original command being run.")
-(make-variable-buffer-local 'mc--this-command)
-
-(defun mc/make-a-note-of-the-command-being-run ()
-  "Used with pre-command-hook to store the original command being run.
-Since that cannot be reliably determined in the post-command-hook.
-
-Specifically, this-original-command isn't always right, because it could have
-been remapped. And certain modes (cua comes to mind) will change their
-remapping based on state. So a command that changes the state will afterwards
-not be recognized through the command-remapping lookup."
-  (unless mc--executing-command-for-fake-cursor
-    (let ((cmd (or (command-remapping this-original-command)
-                   this-original-command)))
-      (setq mc--this-command (and (not (eq cmd 'god-mode-self-insert))
-                                  cmd)))))
-
-(defun mc/execute-this-command-for-all-cursors ()
-  "Wrap around `mc/execute-this-command-for-all-cursors-1' to protect hook."
-  (condition-case error
-      (mc/execute-this-command-for-all-cursors-1)
-    (error
-     (message "[mc] problem in `mc/execute-this-command-for-all-cursors': %s"
-              (error-message-string error)))))
-
-;; execute-kbd-macro should never be run for fake cursors. The real cursor will
-;; execute the keyboard macro, resulting in new commands in the command loop,
-;; and the fake cursors can pick up on those instead.
-(defadvice execute-kbd-macro (around skip-fake-cursors activate)
-  (unless mc--executing-command-for-fake-cursor
-    ad-do-it))
-
-(defun mc/execute-this-command-for-all-cursors-1 ()
-  "Used with post-command-hook to execute supported commands for all cursors.
-
-It uses two lists of commands to know what to do: the run-once
-list and the run-for-all list. If a command is in neither of these lists,
-it will prompt for the proper action and then save that preference.
-
-Some commands are so unsupported that they are even prevented for
-the original cursor, to inform about the lack of support."
-  (unless mc--executing-command-for-fake-cursor
-
-    (if (eq 1 (mc/num-cursors)) ;; no fake cursors? disable mc-mode
-        (multiple-cursors-mode 0)
-      (when this-original-command
-        (let ((original-command (or mc--this-command
-                                    (command-remapping this-original-command)
-                                    this-original-command)))
-
-          ;; skip keyboard macros, since they will generate actual commands that are
-          ;; also run in the command loop - we'll handle those later instead.
-          (when (functionp original-command)
-
-            ;; if it's a lambda, we can't know if it's supported or not
-            ;; - so go ahead and assume it's ok, because we're just optimistic like that
-            (if (or (not (symbolp original-command))
-                    ;; lambda registered by smartrep
-                    (string-prefix-p "(" (symbol-name original-command)))
-                (mc/execute-command-for-all-fake-cursors original-command)
-
-              ;; smartrep `intern's commands into own obarray to help
-              ;; `describe-bindings'.  So, let's re-`intern' here to
-              ;; make the command comparable by `eq'.
-              (setq original-command (intern (symbol-name original-command)))
-
-              ;; otherwise it's a symbol, and we can be more thorough
-              (if (get original-command 'mc--unsupported)
-                  (message "%S is not supported with multiple cursors%s"
-                           original-command
-                           (get original-command 'mc--unsupported))
-
-                ;; lazy-load the user's list file
-                (mc/load-lists)
-
-                (when (and original-command
-                           (not (memq original-command mc--default-cmds-to-run-once))
-                           (not (memq original-command mc/cmds-to-run-once))
-                           (or mc/always-run-for-all
-                               (memq original-command mc--default-cmds-to-run-for-all)
-                               (memq original-command mc/cmds-to-run-for-all)
-                               (mc/prompt-for-inclusion-in-whitelist original-command)))
-                  (mc/execute-command-for-all-fake-cursors original-command))))))))))
-
-(defun mc/remove-fake-cursors ()
-  "Remove all fake cursors.
-Do not use to conclude editing with multiple cursors. For that
-you should disable multiple-cursors-mode."
-  (mc/for-each-fake-cursor
-   (mc/remove-fake-cursor cursor))
-  (when mc--max-cursors-original
-    (setq mc/max-cursors mc--max-cursors-original))
-  (setq mc--max-cursors-original nil))
-
-(defun mc/keyboard-quit ()
-  "Deactivate mark if there are any active, otherwise exit multiple-cursors-mode."
-  (interactive)
-  (if (not (use-region-p))
-      (multiple-cursors-mode 0)
-    (deactivate-mark)))
-
-(defun mc/repeat-command ()
-  "Run last command from `command-history' for every fake cursor."
-  (interactive)
-  (when (or mc/always-repeat-command
-            (y-or-n-p (format "[mc] repeat complex command: %s? " (caar command-history))))
-    (mc/execute-command-for-all-fake-cursors
-     (lambda () (interactive)
-       (cl-letf (((symbol-function 'read-from-minibuffer)
-                  (lambda (p &optional i k r h d m) (read i))))
-         (repeat-complex-command 0))))))
-
-(defvar mc/keymap nil
-  "Keymap while multiple cursors are active.
-Main goal of the keymap is to rebind C-g and <return> to conclude
-multiple cursors editing.")
-(unless mc/keymap
-  (setq mc/keymap (make-sparse-keymap))
-  (define-key mc/keymap (kbd "C-g") 'mc/keyboard-quit)
-  (define-key mc/keymap (kbd "<return>") 'multiple-cursors-mode)
-  (define-key mc/keymap (kbd "C-:") 'mc/repeat-command)
-  (when (fboundp 'phi-search)
-    (define-key mc/keymap (kbd "C-s") 'phi-search))
-  (when (fboundp 'phi-search-backward)
-    (define-key mc/keymap (kbd "C-r") 'phi-search-backward)))
-
-(defun mc--all-equal (list)
-  "Are all the items in LIST equal?"
-  (let ((first (car list))
-        (all-equal t))
-    (while (and all-equal list)
-      (setq all-equal (equal first (car list)))
-      (setq list (cdr list)))
-    all-equal))
-
-(defun mc--kill-ring-entries ()
-  "Return the latest kill-ring entry for each cursor.
-The entries are returned in the order they are found in the buffer."
-  (let (entries)
-    (mc/for-each-cursor-ordered
-     (setq entries (cons (car (overlay-get cursor 'kill-ring)) entries)))
-    (reverse entries)))
-
-(defun mc--maybe-set-killed-rectangle ()
-  "Add the latest kill-ring entry for each cursor to killed-rectangle.
-So you can paste it in later with `yank-rectangle'."
-  (let ((entries (let (mc/max-cursors) (mc--kill-ring-entries))))
-    (unless (mc--all-equal entries)
-      (setq killed-rectangle entries))))
-
-(defvar mc/unsupported-minor-modes '(company-mode auto-complete-mode flyspell-mode jedi-mode)
-  "List of minor-modes that does not play well with multiple-cursors.
-They are temporarily disabled when multiple-cursors are active.")
-
-(defvar mc/temporarily-disabled-minor-modes nil
-  "The list of temporarily disabled minor-modes.")
-(make-variable-buffer-local 'mc/temporarily-disabled-minor-modes)
-
-(defun mc/temporarily-disable-minor-mode (mode)
-  "If MODE is available and turned on, remember that and turn it off."
-  (when (and (boundp mode) (eval mode))
-    (add-to-list 'mc/temporarily-disabled-minor-modes mode)
-    (funcall mode -1)))
-
-(defun mc/temporarily-disable-unsupported-minor-modes ()
-  (mapc 'mc/temporarily-disable-minor-mode mc/unsupported-minor-modes))
-
-(defun mc/enable-minor-mode (mode)
-  (funcall mode 1))
-
-(defun mc/enable-temporarily-disabled-minor-modes ()
-  (mapc 'mc/enable-minor-mode mc/temporarily-disabled-minor-modes)
-  (setq mc/temporarily-disabled-minor-modes nil))
-
-(defcustom mc/mode-line
-  `(" mc:" (:eval (format ,(propertize "%d" 'face 'font-lock-warning-face)
-                          (mc/num-cursors))))
-  "What to display in the mode line while multiple-cursors-mode is active."
-  :group 'multiple-cursors)
-(put 'mc/mode-line 'risky-local-variable t)
-
-;;;###autoload
-(define-minor-mode multiple-cursors-mode
-  "Mode while multiple cursors are active."
-  nil mc/mode-line mc/keymap
-  (if multiple-cursors-mode
-      (progn
-        (mc/temporarily-disable-unsupported-minor-modes)
-        (add-hook 'pre-command-hook 'mc/make-a-note-of-the-command-being-run nil t)
-        (add-hook 'post-command-hook 'mc/execute-this-command-for-all-cursors t t)
-        (run-hooks 'multiple-cursors-mode-enabled-hook))
-    (remove-hook 'post-command-hook 'mc/execute-this-command-for-all-cursors t)
-    (remove-hook 'pre-command-hook 'mc/make-a-note-of-the-command-being-run t)
-    (setq mc--this-command nil)
-    (mc--maybe-set-killed-rectangle)
-    (mc/remove-fake-cursors)
-    (mc/enable-temporarily-disabled-minor-modes)
-    (run-hooks 'multiple-cursors-mode-disabled-hook)))
-
-(add-hook 'after-revert-hook #'(lambda () (multiple-cursors-mode 0)))
-
-(defun mc/maybe-multiple-cursors-mode ()
-  "Enable multiple-cursors-mode if there is more than one currently active cursor."
-  (if (> (mc/num-cursors) 1)
-      (multiple-cursors-mode 1)
-    (multiple-cursors-mode 0)))
-
-(defmacro unsupported-cmd (cmd msg)
-  "Adds command to list of unsupported commands and prevents it
-from being executed if in multiple-cursors-mode."
-  `(progn
-     (put (quote ,cmd) 'mc--unsupported ,msg)
-     (defadvice ,cmd (around unsupported-advice activate)
-       "command isn't supported with multiple cursors"
-       (unless (and multiple-cursors-mode (called-interactively-p 'any))
-         ad-do-it))))
-
-;; Commands that does not work with multiple-cursors
-(unsupported-cmd isearch-forward ". Feel free to add a compatible version.")
-(unsupported-cmd isearch-backward ". Feel free to add a compatible version.")
-
-;; Make sure pastes from other programs are added to all kill-rings when yanking
-(defadvice current-kill (before interprogram-paste-for-all-cursors
-				(n &optional do-not-move) activate)
-  (let ((interprogram-paste (and (= n 0)
-                                 interprogram-paste-function
-                                 (funcall interprogram-paste-function))))
-    (when interprogram-paste
-      ;; Add interprogram-paste to normal kill ring, just
-      ;; like current-kill usually does for itself.
-      ;; We have to do the work for it though, since the funcall only returns
-      ;; something once. It is not a pure function.
-      (let ((interprogram-cut-function nil))
-        (if (listp interprogram-paste)
-            (mapc 'kill-new (nreverse interprogram-paste))
-          (kill-new interprogram-paste))
-        ;; And then add interprogram-paste to the kill-rings
-        ;; of all the other cursors too.
-        (mc/for-each-fake-cursor
-         (let ((kill-ring (overlay-get cursor 'kill-ring))
-               (kill-ring-yank-pointer (overlay-get cursor 'kill-ring-yank-pointer)))
-           (if (listp interprogram-paste)
-               (mapc 'kill-new (nreverse interprogram-paste))
-             (kill-new interprogram-paste))
-           (overlay-put cursor 'kill-ring kill-ring)
-           (overlay-put cursor 'kill-ring-yank-pointer kill-ring-yank-pointer)))))))
-
-(defcustom mc/list-file (locate-user-emacs-file ".mc-lists.el")
-  "The position of the file that keeps track of your preferences
-for running commands with multiple cursors."
-  :type 'file
-  :group 'multiple-cursors)
-
-(defvar mc--list-file-loaded nil
-  "Whether the list file has already been loaded.")
-
-(defun mc/load-lists ()
-  "Loads preferences for running commands with multiple cursors from `mc/list-file'"
-  (unless mc--list-file-loaded
-    (load mc/list-file 'noerror 'nomessage)
-    (setq mc--list-file-loaded t)))
-
-(defun mc/dump-list (list-symbol)
-  "Insert (setq 'LIST-SYMBOL LIST-VALUE) to current buffer."
-  (cl-symbol-macrolet ((value (symbol-value list-symbol)))
-    (insert "(setq " (symbol-name list-symbol) "\n"
-            "      '(")
-    (newline-and-indent)
-    (set list-symbol
-         (sort value (lambda (x y) (string-lessp (symbol-name x)
-                                            (symbol-name y)))))
-    (mapc #'(lambda (cmd) (insert (format "%S" cmd)) (newline-and-indent))
-          value)
-    (insert "))")
-    (newline)))
-
-(defun mc/save-lists ()
-  "Saves preferences for running commands with multiple cursors to `mc/list-file'"
-  (with-temp-file mc/list-file
-    (emacs-lisp-mode)
-    (insert ";; This file is automatically generated by the multiple-cursors extension.")
-    (newline)
-    (insert ";; It keeps track of your preferences for running commands with multiple cursors.")
-    (newline)
-    (newline)
-    (mc/dump-list 'mc/cmds-to-run-for-all)
-    (newline)
-    (mc/dump-list 'mc/cmds-to-run-once)))
-
-(defvar mc/cmds-to-run-once nil
-  "Commands to run only once in multiple-cursors-mode.")
-
-(defvar mc--default-cmds-to-run-once nil
-  "Default set of commands to run only once in multiple-cursors-mode.")
-
-(setq mc--default-cmds-to-run-once '(mc/edit-lines
-                                     mc/edit-ends-of-lines
-                                     mc/edit-beginnings-of-lines
-                                     mc/mark-next-like-this
-				     mc/mark-next-like-this-word
-				     mc/mark-next-like-this-symbol
-                                     mc/mark-next-word-like-this
-                                     mc/mark-next-symbol-like-this
-                                     mc/mark-previous-like-this
-                                     mc/mark-previous-like-this-word
-                                     mc/mark-previous-like-this-symbol
-                                     mc/mark-previous-word-like-this
-                                     mc/mark-previous-symbol-like-this
-                                     mc/mark-all-like-this
-                                     mc/mark-all-words-like-this
-                                     mc/mark-all-symbols-like-this
-                                     mc/mark-more-like-this-extended
-                                     mc/mark-all-like-this-in-defun
-                                     mc/mark-all-words-like-this-in-defun
-                                     mc/mark-all-symbols-like-this-in-defun
-                                     mc/mark-all-like-this-dwim
-                                     mc/mark-all-dwim
-                                     mc/mark-sgml-tag-pair
-                                     mc/insert-numbers
-				     mc/insert-letters
-                                     mc/sort-regions
-                                     mc/reverse-regions
-                                     mc/cycle-forward
-                                     mc/cycle-backward
-                                     mc/add-cursor-on-click
-                                     mc/mark-pop
-                                     mc/add-cursors-to-all-matches
-                                     mc/mmlte--left
-                                     mc/mmlte--right
-                                     mc/mmlte--up
-                                     mc/mmlte--down
-                                     mc/unmark-next-like-this
-                                     mc/unmark-previous-like-this
-                                     mc/skip-to-next-like-this
-                                     mc/skip-to-previous-like-this
-                                     rrm/switch-to-multiple-cursors
-                                     mc-hide-unmatched-lines-mode
-                                     mc/repeat-command
-                                     hum/keyboard-quit
-                                     hum/unhide-invisible-overlays
-                                     save-buffer
-                                     ido-exit-minibuffer
-                                     ivy-done
-                                     exit-minibuffer
-                                     minibuffer-complete-and-exit
-                                     execute-extended-command
-                                     eval-expression
-                                     undo
-                                     redo
-                                     undo-tree-undo
-                                     undo-tree-redo
-                                     universal-argument
-                                     universal-argument-more
-                                     universal-argument-other-key
-                                     negative-argument
-                                     digit-argument
-                                     top-level
-                                     recenter-top-bottom
-                                     describe-mode
-                                     describe-key-1
-                                     describe-function
-                                     describe-bindings
-                                     describe-prefix-bindings
-                                     view-echo-area-messages
-                                     other-window
-                                     kill-buffer-and-window
-                                     split-window-right
-                                     split-window-below
-                                     delete-other-windows
-                                     toggle-window-split
-                                     mwheel-scroll
-                                     scroll-up-command
-                                     scroll-down-command
-                                     mouse-set-point
-                                     mouse-drag-region
-                                     quit-window
-                                     toggle-read-only
-                                     windmove-left
-                                     windmove-right
-                                     windmove-up
-                                     windmove-down
-                                     repeat-complex-command))
-
-(defvar mc--default-cmds-to-run-for-all nil
-  "Default set of commands that should be mirrored by all cursors")
-
-(setq mc--default-cmds-to-run-for-all '(mc/keyboard-quit
-                                        self-insert-command
-                                        quoted-insert
-                                        previous-line
-                                        next-line
-                                        newline
-                                        newline-and-indent
-                                        open-line
-                                        delete-blank-lines
-                                        transpose-chars
-                                        transpose-lines
-                                        transpose-paragraphs
-                                        transpose-regions
-                                        join-line
-                                        right-char
-                                        right-word
-                                        forward-char
-                                        forward-word
-                                        left-char
-                                        left-word
-                                        backward-char
-                                        backward-word
-                                        forward-paragraph
-                                        backward-paragraph
-                                        upcase-word
-                                        downcase-word
-                                        capitalize-word
-                                        forward-list
-                                        backward-list
-                                        hippie-expand
-                                        hippie-expand-lines
-                                        yank
-                                        yank-pop
-                                        append-next-kill
-                                        kill-word
-                                        kill-line
-                                        kill-whole-line
-                                        backward-kill-word
-                                        backward-delete-char-untabify
-                                        delete-char delete-forward-char
-                                        delete-backward-char
-                                        py-electric-backspace
-                                        c-electric-backspace
-                                        org-delete-backward-char
-                                        cperl-electric-backspace
-                                        python-indent-dedent-line-backspace
-                                        paredit-backward-delete
-                                        autopair-backspace
-                                        just-one-space
-                                        zap-to-char
-                                        end-of-line
-                                        set-mark-command
-                                        exchange-point-and-mark
-                                        cua-set-mark
-                                        cua-replace-region
-                                        cua-delete-region
-                                        move-end-of-line
-                                        beginning-of-line
-                                        move-beginning-of-line
-                                        kill-ring-save
-                                        back-to-indentation
-                                        subword-forward
-                                        subword-backward
-                                        subword-mark
-                                        subword-kill
-                                        subword-backward-kill
-                                        subword-transpose
-                                        subword-capitalize
-                                        subword-upcase
-                                        subword-downcase
-                                        er/expand-region
-                                        er/contract-region
-                                        smart-forward
-                                        smart-backward
-                                        smart-up
-                                        smart-down))
-
-(defvar mc/cmds-to-run-for-all nil
-  "Commands to run for all cursors in multiple-cursors-mode")
-
-(provide 'multiple-cursors-core)
-
-;; Local Variables:
-;; coding: utf-8
-;; End:
-
-;;; multiple-cursors-core.el ends here
diff --git a/elpa/multiple-cursors-20191210.1759/multiple-cursors-core.elc b/elpa/multiple-cursors-20191210.1759/multiple-cursors-core.elc
deleted file mode 100644
index 2efd5f3e..00000000
Binary files a/elpa/multiple-cursors-20191210.1759/multiple-cursors-core.elc and /dev/null differ
diff --git a/elpa/multiple-cursors-20191210.1759/multiple-cursors-pkg.el b/elpa/multiple-cursors-20191210.1759/multiple-cursors-pkg.el
deleted file mode 100644
index ceb4014f..00000000
--- a/elpa/multiple-cursors-20191210.1759/multiple-cursors-pkg.el
+++ /dev/null
@@ -1,5 +0,0 @@
-(define-package "multiple-cursors" "20191210.1759" "Multiple cursors for Emacs."
-  '((cl-lib "0.5")))
-;; Local Variables:
-;; no-byte-compile: t
-;; End:
diff --git a/elpa/multiple-cursors-20191210.1759/multiple-cursors.el b/elpa/multiple-cursors-20191210.1759/multiple-cursors.el
deleted file mode 100644
index e78bab37..00000000
--- a/elpa/multiple-cursors-20191210.1759/multiple-cursors.el
+++ /dev/null
@@ -1,203 +0,0 @@
-;;; multiple-cursors.el --- Multiple cursors for emacs.
-
-;; Copyright (C) 2012-2016 Magnar Sveen
-
-;; Author: Magnar Sveen <magnars@gmail.com>
-;; Version: 1.4.0
-;; Keywords: editing cursors
-
-;; 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:
-
-;; Multiple cursors for Emacs. This is some pretty crazy functionality, so yes,
-;; there are kinks. Don't be afraid though, I've been using it since 2011 with
-;; great success and much merriment.
-
-;; ## Basic usage
-
-;; Start out with:
-
-;;     (require 'multiple-cursors)
-
-;; Then you have to set up your keybindings - multiple-cursors doesn't presume to
-;; know how you'd like them laid out. Here are some examples:
-
-;; When you have an active region that spans multiple lines, the following will
-;; add a cursor to each line:
-
-;;     (global-set-key (kbd "C-S-c C-S-c") 'mc/edit-lines)
-
-;; When you want to add multiple cursors not based on continuous lines, but based on
-;; keywords in the buffer, use:
-
-;;     (global-set-key (kbd "C->") 'mc/mark-next-like-this)
-;;     (global-set-key (kbd "C-<") 'mc/mark-previous-like-this)
-;;     (global-set-key (kbd "C-c C-<") 'mc/mark-all-like-this)
-
-;; First mark the word, then add more cursors.
-
-;; To get out of multiple-cursors-mode, press `<return>` or `C-g`. The latter will
-;; first disable multiple regions before disabling multiple cursors. If you want to
-;; insert a newline in multiple-cursors-mode, use `C-j`.
-
-;; ## Video
-
-;; You can [watch an intro to multiple-cursors at Emacs Rocks](http://emacsrocks.com/e13.html).
-
-;; ## Command overview
-
-;; ### Mark one more occurrence
-
-;;  - `mc/mark-next-like-this`: Adds a cursor and region at the next part of the buffer forwards that matches the current region.
-;;  - `mc/mark-next-like-this-word`: Adds a cursor and region at the next part of the buffer forwards that matches the current region, if  no region is selected it selects the word at the point.
-;;  - `mc/mark-next-like-this-symbol`: Adds a cursor and region at the next part of the buffer forwards that matches the current region, if  no region is selected it selects the symbol at the point.
-;;  - `mc/mark-next-word-like-this`: Like `mc/mark-next-like-this` but only for whole words.
-;;  - `mc/mark-next-symbol-like-this`: Like `mc/mark-next-like-this` but only for whole symbols.
-;;  - `mc/mark-previous-like-this`: Adds a cursor and region at the next part of the buffer backwards that matches the current region.
-;;  - `mc/mark-previous-word-like-this`: Like `mc/mark-previous-like-this` but only for whole words.
-;;  - `mc/mark-previous-symbol-like-this`: Like `mc/mark-previous-like-this` but only for whole symbols.
-;;  - `mc/mark-more-like-this-extended`: Use arrow keys to quickly mark/skip next/previous occurrences.
-;;  - `mc/add-cursor-on-click`: Bind to a mouse event to add cursors by clicking. See tips-section.
-
-;; ### Mark many occurrences
-
-;;  - `mc/mark-all-like-this`: Marks all parts of the buffer that matches the current region.
-;;  - `mc/mark-all-words-like-this`: Like `mc/mark-all-like-this` but only for whole words.
-;;  - `mc/mark-all-symbols-like-this`: Like `mc/mark-all-like-this` but only for whole symbols.
-;;  - `mc/mark-all-in-region`: Prompts for a string to match in the region, adding cursors to all of them.
-;;  - `mc/mark-all-like-this-in-defun`: Marks all parts of the current defun that matches the current region.
-;;  - `mc/mark-all-words-like-this-in-defun`: Like `mc/mark-all-like-this-in-defun` but only for whole words.
-;;  - `mc/mark-all-symbols-like-this-in-defun`: Like `mc/mark-all-like-this-in-defun` but only for whole symbols.
-;;  - `mc/mark-all-like-this-dwim`: Tries to be smart about marking everything you want. Can be pressed multiple times.
-
-;; ### Special
-
-;;  - `set-rectangular-region-anchor`: Think of this one as `set-mark` except you're marking a rectangular region.
-;;  - `mc/mark-sgml-tag-pair`: Mark the current opening and closing tag.
-;;  - `mc/insert-numbers`: Insert increasing numbers for each cursor, top to bottom.
-;;  - `mc/insert-letters`: Insert increasing letters for each cursor, top to bottom.
-;;  - `mc/sort-regions`: Sort the marked regions alphabetically.
-;;  - `mc/reverse-regions`: Reverse the order of the marked regions.
-
-;; ## Tips and tricks
-
-;; - To get out of multiple-cursors-mode, press `<return>` or `C-g`. The latter will
-;;   first disable multiple regions before disabling multiple cursors. If you want to
-;;   insert a newline in multiple-cursors-mode, use `C-j`.
-;;
-;; - Sometimes you end up with cursors outside of your view. You can
-;;   scroll the screen to center on each cursor with `C-v` and `M-v`.
-;;
-;; - Try pressing `mc/mark-next-like-this` with no region selected. It will just add a cursor
-;;   on the next line.
-;;
-;; - Try pressing `mc/mark-next-like-this-word` or
-;;   `mc/mark-next-like-this-symbol` with no region selected. It will
-;;   mark the symbol and add a cursor at the next occurrence
-;;
-;; - Try pressing `mc/mark-all-like-this-dwim` on a tagname in html-mode.
-;;
-;; - Notice that the number of cursors active can be seen in the modeline.
-;;
-;; - If you get out of multiple-cursors-mode and yank - it will yank only
-;;   from the kill-ring of main cursor. To yank from the kill-rings of
-;;   every cursor use yank-rectangle, normally found at C-x r y.
-;;
-;; - You can use `mc/reverse-regions` with nothing selected and just one cursor.
-;;   It will then flip the sexp at point and the one below it.
-;;
-;; - If you would like to keep the global bindings clean, and get custom keybindings
-;;   when the region is active, you can try [region-bindings-mode](https://github.com/fgallina/region-bindings-mode).
-;;
-;; BTW, I highly recommend adding `mc/mark-next-like-this` to a key binding that's
-;; right next to the key for `er/expand-region`.
-
-;; ### Binding mouse events
-
-;; To override a mouse event, you will likely have to also unbind the
-;; `down-mouse` part of the event. Like this:
-;;
-;;     (global-unset-key (kbd "M-<down-mouse-1>"))
-;;     (global-set-key (kbd "M-<mouse-1>") 'mc/add-cursor-on-click)
-;;
-;; Or you can do like me and find an unused, but less convenient, binding:
-;;
-;;     (global-set-key (kbd "C-S-<mouse-1>") 'mc/add-cursor-on-click)
-
-;; ## Unknown commands
-
-;; Multiple-cursors uses two lists of commands to know what to do: the run-once list
-;; and the run-for-all list. It comes with a set of defaults, but it would be beyond silly
-;; to try and include all the known Emacs commands.
-
-;; So that's why multiple-cursors occasionally asks what to do about a command. It will
-;; then remember your choice by saving it in `~/.emacs.d/.mc-lists.el`. You can change
-;; the location with:
-
-;;     (setq mc/list-file "/my/preferred/file")
-
-;; ## Known limitations
-
-;; * isearch-forward and isearch-backward aren't supported with multiple cursors.
-;;   You should feel free to add a simplified version that can work with it.
-;; * Commands run with `M-x` won't be repeated for all cursors.
-;; * All key bindings that refer to lambdas are always run for all cursors. If you
-;;   need to limit it, you will have to give it a name.
-;; * Redo might screw with your cursors. Undo works very well.
-
-;; ## Contribute
-
-;; Yes, please do. There's a suite of tests, so remember to add tests for your
-;; specific feature, or I might break it later.
-
-;; You'll find the repo at:
-
-;;     https://github.com/magnars/multiple-cursors.el
-
-;; To fetch the test dependencies:
-
-;;     $ cd /path/to/multiple-cursors
-;;     $ git submodule update --init
-
-;; Run the tests with:
-
-;;     $ ./util/ecukes/ecukes --graphical
-
-;; ## Contributors
-
-;; * [Takafumi Arakaki](https://github.com/tkf) made .mc-lists.el diff friendly
-;; * [Marco Baringer](https://github.com/segv) contributed looping to mc/cycle and adding cursors without region for mark-more.
-;; * [Ivan Andrus](https://github.com/gvol) added showing number of cursors in mode-line
-;; * [Fuco](https://github.com/Fuco1) added the first version of `mc/mark-all-like-this-dwim`
-
-;; Thanks!
-
-;;; Code:
-
-(defgroup multiple-cursors nil
-  "Multiple cursors for emacs."
-  :group 'editing)
-
-(require 'mc-edit-lines)
-(require 'mc-cycle-cursors)
-(require 'mc-mark-more)
-(require 'mc-mark-pop)
-(require 'rectangular-region-mode)
-(require 'mc-separate-operations)
-(require 'mc-hide-unmatched-lines-mode)
-
-(provide 'multiple-cursors)
-
-;;; multiple-cursors.el ends here
diff --git a/elpa/multiple-cursors-20191210.1759/multiple-cursors.elc b/elpa/multiple-cursors-20191210.1759/multiple-cursors.elc
deleted file mode 100644
index 953b4acf..00000000
Binary files a/elpa/multiple-cursors-20191210.1759/multiple-cursors.elc and /dev/null differ
diff --git a/elpa/multiple-cursors-20191210.1759/rectangular-region-mode.el b/elpa/multiple-cursors-20191210.1759/rectangular-region-mode.el
deleted file mode 100644
index d8051cca..00000000
--- a/elpa/multiple-cursors-20191210.1759/rectangular-region-mode.el
+++ /dev/null
@@ -1,125 +0,0 @@
-;;; rectangular-region-mode.el
-
-;; Copyright (C) 2012-2016 Magnar Sveen
-
-;; Author: Magnar Sveen <magnars@gmail.com>
-;; Keywords: editing cursors
-
-;; 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:
-
-;; (global-set-key (kbd "H-SPC") 'set-rectangular-region-anchor)
-
-;; Think of this one as `set-mark` except you're marking a rectangular region. It is
-;; an exceedingly quick way of adding multiple cursors to multiple lines.
-
-;;; Code:
-
-(require 'multiple-cursors-core)
-
-(defvar rrm/anchor (make-marker)
-  "The position in the buffer that anchors the rectangular region.")
-
-(defvar rectangular-region-mode-map (make-sparse-keymap)
-  "Keymap for rectangular region is mainly for rebinding C-g")
-
-(define-key rectangular-region-mode-map (kbd "C-g") 'rrm/keyboard-quit)
-(define-key rectangular-region-mode-map (kbd "<return>") 'rrm/switch-to-multiple-cursors)
-
-(defvar rectangular-region-mode nil)
-
-(defun rrm/keyboard-quit ()
-  "Exit rectangular-region-mode."
-  (interactive)
-  (rectangular-region-mode 0)
-  (rrm/remove-rectangular-region-overlays)
-  (deactivate-mark))
-
-;; Bind this to a key (for instance H-SPC) to start rectangular-region-mode
-;;;###autoload
-(defun set-rectangular-region-anchor ()
-  "Anchors the rectangular region at point.
-
-Think of this one as `set-mark' except you're marking a rectangular region. It is
-an exceedingly quick way of adding multiple cursors to multiple lines."
-  (interactive)
-  (set-marker rrm/anchor (point))
-  (push-mark (point))
-  (rectangular-region-mode 1))
-
-(defun rrm/remove-rectangular-region-overlays ()
-  "Remove all rectangular-region overlays."
-  (mc/remove-fake-cursors)
-  (mapc #'(lambda (o)
-            (when (eq (overlay-get o 'type) 'additional-region)
-              (delete-overlay o)))
-        (overlays-in (point-min) (point-max))))
-
-(defun rrm/repaint ()
-  "Start from the anchor and draw a rectangle between it and point."
-  (if (not rectangular-region-mode)
-      (remove-hook 'post-command-hook 'rrm/repaint t)
-    ;; else
-    (rrm/remove-rectangular-region-overlays)
-    (let* ((annoying-arrows-mode nil)
-           (point-column (current-column))
-           (point-line (mc/line-number-at-pos))
-           (anchor-column (save-excursion (goto-char rrm/anchor) (current-column)))
-           (anchor-line (save-excursion (goto-char rrm/anchor) (mc/line-number-at-pos)))
-           (left-column (if (< point-column anchor-column) point-column anchor-column))
-           (right-column (if (> point-column anchor-column) point-column anchor-column))
-           (navigation-step (if (< point-line anchor-line) 1 -1)))
-      (move-to-column anchor-column)
-      (set-mark (point))
-      (move-to-column point-column)
-      (mc/save-excursion
-       (while (not (= anchor-line (mc/line-number-at-pos)))
-         (forward-line navigation-step)
-         (move-to-column anchor-column)
-         (when (= anchor-column (current-column))
-           (set-mark (point))
-           (move-to-column point-column)
-           (when (= point-column (current-column))
-             (mc/create-fake-cursor-at-point))))))))
-
-(defun rrm/switch-to-multiple-cursors (&rest forms)
-  "Switch from rectangular-region-mode to multiple-cursors-mode."
-  (interactive)
-  (rectangular-region-mode 0)
-  (multiple-cursors-mode 1))
-
-(defadvice er/expand-region (before switch-from-rrm-to-mc activate)
-  (when rectangular-region-mode
-    (rrm/switch-to-multiple-cursors)))
-
-(defadvice kill-ring-save (before switch-from-rrm-to-mc activate)
-  (when rectangular-region-mode
-    (rrm/switch-to-multiple-cursors)))
-
-;;;###autoload
-(define-minor-mode rectangular-region-mode
-  "A mode for creating a rectangular region to edit"
-  nil " rr" rectangular-region-mode-map
-  (if rectangular-region-mode
-      (progn
-        (add-hook 'after-change-functions 'rrm/switch-to-multiple-cursors t t)
-        (add-hook 'post-command-hook 'rrm/repaint t t))
-    (remove-hook 'after-change-functions 'rrm/switch-to-multiple-cursors t)
-    (remove-hook 'post-command-hook 'rrm/repaint t)
-    (set-marker rrm/anchor nil)))
-
-(provide 'rectangular-region-mode)
-
-;;; rectangular-region-mode.el ends here
diff --git a/elpa/multiple-cursors-20191210.1759/rectangular-region-mode.elc b/elpa/multiple-cursors-20191210.1759/rectangular-region-mode.elc
deleted file mode 100644
index 1261c5b8..00000000
Binary files a/elpa/multiple-cursors-20191210.1759/rectangular-region-mode.elc and /dev/null differ
diff --git a/elpa/org-9.3.2.signed b/elpa/org-9.3.2.signed
deleted file mode 100644
index d7938f4e..00000000
--- a/elpa/org-9.3.2.signed
+++ /dev/null
@@ -1 +0,0 @@
-Good signature from 066DAFCB81E42C40 GNU ELPA Signing Agent (2019) <elpasign@elpa.gnu.org> (trust undefined) created at 2020-01-26T23:05:02+0100 using RSA
\ No newline at end of file
diff --git a/elpa/org-9.3.3.signed b/elpa/org-9.3.3.signed
new file mode 100644
index 00000000..3bd9b4a6
--- /dev/null
+++ b/elpa/org-9.3.3.signed
@@ -0,0 +1 @@
+Good signature from 066DAFCB81E42C40 GNU ELPA Signing Agent (2019) <elpasign@elpa.gnu.org> (trust undefined) created at 2020-02-05T11:05:09+0100 using RSA
\ No newline at end of file
diff --git a/elpa/org-9.3.2/COPYING b/elpa/org-9.3.3/COPYING
similarity index 100%
rename from elpa/org-9.3.2/COPYING
rename to elpa/org-9.3.3/COPYING
diff --git a/elpa/org-9.3.2/README_ELPA b/elpa/org-9.3.3/README_ELPA
similarity index 100%
rename from elpa/org-9.3.2/README_ELPA
rename to elpa/org-9.3.3/README_ELPA
diff --git a/elpa/org-9.3.2/dir b/elpa/org-9.3.3/dir
similarity index 100%
rename from elpa/org-9.3.2/dir
rename to elpa/org-9.3.3/dir
diff --git a/elpa/org-9.3.2/etc/ORG-NEWS b/elpa/org-9.3.3/etc/ORG-NEWS
similarity index 100%
rename from elpa/org-9.3.2/etc/ORG-NEWS
rename to elpa/org-9.3.3/etc/ORG-NEWS
diff --git a/elpa/org-9.3.2/etc/styles/OrgOdtContentTemplate.xml b/elpa/org-9.3.3/etc/styles/OrgOdtContentTemplate.xml
similarity index 100%
rename from elpa/org-9.3.2/etc/styles/OrgOdtContentTemplate.xml
rename to elpa/org-9.3.3/etc/styles/OrgOdtContentTemplate.xml
diff --git a/elpa/org-9.3.2/etc/styles/OrgOdtStyles.xml b/elpa/org-9.3.3/etc/styles/OrgOdtStyles.xml
similarity index 100%
rename from elpa/org-9.3.2/etc/styles/OrgOdtStyles.xml
rename to elpa/org-9.3.3/etc/styles/OrgOdtStyles.xml
diff --git a/elpa/org-9.3.2/etc/styles/README b/elpa/org-9.3.3/etc/styles/README
similarity index 100%
rename from elpa/org-9.3.2/etc/styles/README
rename to elpa/org-9.3.3/etc/styles/README
diff --git a/elpa/org-9.3.2/ob-C.el b/elpa/org-9.3.3/ob-C.el
similarity index 100%
rename from elpa/org-9.3.2/ob-C.el
rename to elpa/org-9.3.3/ob-C.el
diff --git a/elpa/org-9.3.2/ob-C.elc b/elpa/org-9.3.3/ob-C.elc
similarity index 100%
rename from elpa/org-9.3.2/ob-C.elc
rename to elpa/org-9.3.3/ob-C.elc
diff --git a/elpa/org-9.3.2/ob-J.el b/elpa/org-9.3.3/ob-J.el
similarity index 100%
rename from elpa/org-9.3.2/ob-J.el
rename to elpa/org-9.3.3/ob-J.el
diff --git a/elpa/org-9.3.2/ob-J.elc b/elpa/org-9.3.3/ob-J.elc
similarity index 100%
rename from elpa/org-9.3.2/ob-J.elc
rename to elpa/org-9.3.3/ob-J.elc
diff --git a/elpa/org-9.3.2/ob-R.el b/elpa/org-9.3.3/ob-R.el
similarity index 100%
rename from elpa/org-9.3.2/ob-R.el
rename to elpa/org-9.3.3/ob-R.el
diff --git a/elpa/org-9.3.2/ob-R.elc b/elpa/org-9.3.3/ob-R.elc
similarity index 100%
rename from elpa/org-9.3.2/ob-R.elc
rename to elpa/org-9.3.3/ob-R.elc
diff --git a/elpa/org-9.3.2/ob-abc.el b/elpa/org-9.3.3/ob-abc.el
similarity index 100%
rename from elpa/org-9.3.2/ob-abc.el
rename to elpa/org-9.3.3/ob-abc.el
diff --git a/elpa/org-9.3.2/ob-abc.elc b/elpa/org-9.3.3/ob-abc.elc
similarity index 100%
rename from elpa/org-9.3.2/ob-abc.elc
rename to elpa/org-9.3.3/ob-abc.elc
diff --git a/elpa/org-9.3.2/ob-asymptote.el b/elpa/org-9.3.3/ob-asymptote.el
similarity index 100%
rename from elpa/org-9.3.2/ob-asymptote.el
rename to elpa/org-9.3.3/ob-asymptote.el
diff --git a/elpa/org-9.3.2/ob-asymptote.elc b/elpa/org-9.3.3/ob-asymptote.elc
similarity index 100%
rename from elpa/org-9.3.2/ob-asymptote.elc
rename to elpa/org-9.3.3/ob-asymptote.elc
diff --git a/elpa/org-9.3.2/ob-awk.el b/elpa/org-9.3.3/ob-awk.el
similarity index 100%
rename from elpa/org-9.3.2/ob-awk.el
rename to elpa/org-9.3.3/ob-awk.el
diff --git a/elpa/org-9.3.2/ob-awk.elc b/elpa/org-9.3.3/ob-awk.elc
similarity index 100%
rename from elpa/org-9.3.2/ob-awk.elc
rename to elpa/org-9.3.3/ob-awk.elc
diff --git a/elpa/org-9.3.2/ob-calc.el b/elpa/org-9.3.3/ob-calc.el
similarity index 100%
rename from elpa/org-9.3.2/ob-calc.el
rename to elpa/org-9.3.3/ob-calc.el
diff --git a/elpa/org-9.3.2/ob-calc.elc b/elpa/org-9.3.3/ob-calc.elc
similarity index 100%
rename from elpa/org-9.3.2/ob-calc.elc
rename to elpa/org-9.3.3/ob-calc.elc
diff --git a/elpa/org-9.3.2/ob-clojure.el b/elpa/org-9.3.3/ob-clojure.el
similarity index 100%
rename from elpa/org-9.3.2/ob-clojure.el
rename to elpa/org-9.3.3/ob-clojure.el
diff --git a/elpa/org-9.3.2/ob-clojure.elc b/elpa/org-9.3.3/ob-clojure.elc
similarity index 100%
rename from elpa/org-9.3.2/ob-clojure.elc
rename to elpa/org-9.3.3/ob-clojure.elc
diff --git a/elpa/org-9.3.2/ob-comint.el b/elpa/org-9.3.3/ob-comint.el
similarity index 100%
rename from elpa/org-9.3.2/ob-comint.el
rename to elpa/org-9.3.3/ob-comint.el
diff --git a/elpa/org-9.3.2/ob-comint.elc b/elpa/org-9.3.3/ob-comint.elc
similarity index 100%
rename from elpa/org-9.3.2/ob-comint.elc
rename to elpa/org-9.3.3/ob-comint.elc
diff --git a/elpa/org-9.3.2/ob-coq.el b/elpa/org-9.3.3/ob-coq.el
similarity index 100%
rename from elpa/org-9.3.2/ob-coq.el
rename to elpa/org-9.3.3/ob-coq.el
diff --git a/elpa/org-9.3.2/ob-coq.elc b/elpa/org-9.3.3/ob-coq.elc
similarity index 100%
rename from elpa/org-9.3.2/ob-coq.elc
rename to elpa/org-9.3.3/ob-coq.elc
diff --git a/elpa/org-9.3.2/ob-core.el b/elpa/org-9.3.3/ob-core.el
similarity index 100%
rename from elpa/org-9.3.2/ob-core.el
rename to elpa/org-9.3.3/ob-core.el
diff --git a/elpa/org-9.3.2/ob-core.elc b/elpa/org-9.3.3/ob-core.elc
similarity index 100%
rename from elpa/org-9.3.2/ob-core.elc
rename to elpa/org-9.3.3/ob-core.elc
diff --git a/elpa/org-9.3.2/ob-css.el b/elpa/org-9.3.3/ob-css.el
similarity index 100%
rename from elpa/org-9.3.2/ob-css.el
rename to elpa/org-9.3.3/ob-css.el
diff --git a/elpa/org-9.3.2/ob-css.elc b/elpa/org-9.3.3/ob-css.elc
similarity index 100%
rename from elpa/org-9.3.2/ob-css.elc
rename to elpa/org-9.3.3/ob-css.elc
diff --git a/elpa/org-9.3.2/ob-ditaa.el b/elpa/org-9.3.3/ob-ditaa.el
similarity index 100%
rename from elpa/org-9.3.2/ob-ditaa.el
rename to elpa/org-9.3.3/ob-ditaa.el
diff --git a/elpa/org-9.3.2/ob-ditaa.elc b/elpa/org-9.3.3/ob-ditaa.elc
similarity index 100%
rename from elpa/org-9.3.2/ob-ditaa.elc
rename to elpa/org-9.3.3/ob-ditaa.elc
diff --git a/elpa/org-9.3.2/ob-dot.el b/elpa/org-9.3.3/ob-dot.el
similarity index 100%
rename from elpa/org-9.3.2/ob-dot.el
rename to elpa/org-9.3.3/ob-dot.el
diff --git a/elpa/org-9.3.2/ob-dot.elc b/elpa/org-9.3.3/ob-dot.elc
similarity index 100%
rename from elpa/org-9.3.2/ob-dot.elc
rename to elpa/org-9.3.3/ob-dot.elc
diff --git a/elpa/org-9.3.2/ob-ebnf.el b/elpa/org-9.3.3/ob-ebnf.el
similarity index 100%
rename from elpa/org-9.3.2/ob-ebnf.el
rename to elpa/org-9.3.3/ob-ebnf.el
diff --git a/elpa/org-9.3.2/ob-ebnf.elc b/elpa/org-9.3.3/ob-ebnf.elc
similarity index 100%
rename from elpa/org-9.3.2/ob-ebnf.elc
rename to elpa/org-9.3.3/ob-ebnf.elc
diff --git a/elpa/org-9.3.2/ob-emacs-lisp.el b/elpa/org-9.3.3/ob-emacs-lisp.el
similarity index 100%
rename from elpa/org-9.3.2/ob-emacs-lisp.el
rename to elpa/org-9.3.3/ob-emacs-lisp.el
diff --git a/elpa/org-9.3.2/ob-emacs-lisp.elc b/elpa/org-9.3.3/ob-emacs-lisp.elc
similarity index 100%
rename from elpa/org-9.3.2/ob-emacs-lisp.elc
rename to elpa/org-9.3.3/ob-emacs-lisp.elc
diff --git a/elpa/org-9.3.2/ob-eshell.el b/elpa/org-9.3.3/ob-eshell.el
similarity index 100%
rename from elpa/org-9.3.2/ob-eshell.el
rename to elpa/org-9.3.3/ob-eshell.el
diff --git a/elpa/org-9.3.2/ob-eshell.elc b/elpa/org-9.3.3/ob-eshell.elc
similarity index 100%
rename from elpa/org-9.3.2/ob-eshell.elc
rename to elpa/org-9.3.3/ob-eshell.elc
diff --git a/elpa/org-9.3.2/ob-eval.el b/elpa/org-9.3.3/ob-eval.el
similarity index 100%
rename from elpa/org-9.3.2/ob-eval.el
rename to elpa/org-9.3.3/ob-eval.el
diff --git a/elpa/org-9.3.2/ob-eval.elc b/elpa/org-9.3.3/ob-eval.elc
similarity index 100%
rename from elpa/org-9.3.2/ob-eval.elc
rename to elpa/org-9.3.3/ob-eval.elc
diff --git a/elpa/org-9.3.2/ob-exp.el b/elpa/org-9.3.3/ob-exp.el
similarity index 100%
rename from elpa/org-9.3.2/ob-exp.el
rename to elpa/org-9.3.3/ob-exp.el
diff --git a/elpa/org-9.3.2/ob-exp.elc b/elpa/org-9.3.3/ob-exp.elc
similarity index 100%
rename from elpa/org-9.3.2/ob-exp.elc
rename to elpa/org-9.3.3/ob-exp.elc
diff --git a/elpa/org-9.3.2/ob-forth.el b/elpa/org-9.3.3/ob-forth.el
similarity index 100%
rename from elpa/org-9.3.2/ob-forth.el
rename to elpa/org-9.3.3/ob-forth.el
diff --git a/elpa/org-9.3.2/ob-forth.elc b/elpa/org-9.3.3/ob-forth.elc
similarity index 100%
rename from elpa/org-9.3.2/ob-forth.elc
rename to elpa/org-9.3.3/ob-forth.elc
diff --git a/elpa/org-9.3.2/ob-fortran.el b/elpa/org-9.3.3/ob-fortran.el
similarity index 100%
rename from elpa/org-9.3.2/ob-fortran.el
rename to elpa/org-9.3.3/ob-fortran.el
diff --git a/elpa/org-9.3.2/ob-fortran.elc b/elpa/org-9.3.3/ob-fortran.elc
similarity index 100%
rename from elpa/org-9.3.2/ob-fortran.elc
rename to elpa/org-9.3.3/ob-fortran.elc
diff --git a/elpa/org-9.3.2/ob-gnuplot.el b/elpa/org-9.3.3/ob-gnuplot.el
similarity index 100%
rename from elpa/org-9.3.2/ob-gnuplot.el
rename to elpa/org-9.3.3/ob-gnuplot.el
diff --git a/elpa/org-9.3.2/ob-gnuplot.elc b/elpa/org-9.3.3/ob-gnuplot.elc
similarity index 100%
rename from elpa/org-9.3.2/ob-gnuplot.elc
rename to elpa/org-9.3.3/ob-gnuplot.elc
diff --git a/elpa/org-9.3.2/ob-groovy.el b/elpa/org-9.3.3/ob-groovy.el
similarity index 100%
rename from elpa/org-9.3.2/ob-groovy.el
rename to elpa/org-9.3.3/ob-groovy.el
diff --git a/elpa/org-9.3.2/ob-groovy.elc b/elpa/org-9.3.3/ob-groovy.elc
similarity index 100%
rename from elpa/org-9.3.2/ob-groovy.elc
rename to elpa/org-9.3.3/ob-groovy.elc
diff --git a/elpa/org-9.3.2/ob-haskell.el b/elpa/org-9.3.3/ob-haskell.el
similarity index 100%
rename from elpa/org-9.3.2/ob-haskell.el
rename to elpa/org-9.3.3/ob-haskell.el
diff --git a/elpa/org-9.3.2/ob-haskell.elc b/elpa/org-9.3.3/ob-haskell.elc
similarity index 100%
rename from elpa/org-9.3.2/ob-haskell.elc
rename to elpa/org-9.3.3/ob-haskell.elc
diff --git a/elpa/org-9.3.2/ob-hledger.el b/elpa/org-9.3.3/ob-hledger.el
similarity index 100%
rename from elpa/org-9.3.2/ob-hledger.el
rename to elpa/org-9.3.3/ob-hledger.el
diff --git a/elpa/org-9.3.2/ob-hledger.elc b/elpa/org-9.3.3/ob-hledger.elc
similarity index 100%
rename from elpa/org-9.3.2/ob-hledger.elc
rename to elpa/org-9.3.3/ob-hledger.elc
diff --git a/elpa/org-9.3.2/ob-io.el b/elpa/org-9.3.3/ob-io.el
similarity index 100%
rename from elpa/org-9.3.2/ob-io.el
rename to elpa/org-9.3.3/ob-io.el
diff --git a/elpa/org-9.3.2/ob-io.elc b/elpa/org-9.3.3/ob-io.elc
similarity index 100%
rename from elpa/org-9.3.2/ob-io.elc
rename to elpa/org-9.3.3/ob-io.elc
diff --git a/elpa/org-9.3.2/ob-java.el b/elpa/org-9.3.3/ob-java.el
similarity index 100%
rename from elpa/org-9.3.2/ob-java.el
rename to elpa/org-9.3.3/ob-java.el
diff --git a/elpa/org-9.3.2/ob-java.elc b/elpa/org-9.3.3/ob-java.elc
similarity index 100%
rename from elpa/org-9.3.2/ob-java.elc
rename to elpa/org-9.3.3/ob-java.elc
diff --git a/elpa/org-9.3.2/ob-js.el b/elpa/org-9.3.3/ob-js.el
similarity index 100%
rename from elpa/org-9.3.2/ob-js.el
rename to elpa/org-9.3.3/ob-js.el
diff --git a/elpa/org-9.3.2/ob-js.elc b/elpa/org-9.3.3/ob-js.elc
similarity index 100%
rename from elpa/org-9.3.2/ob-js.elc
rename to elpa/org-9.3.3/ob-js.elc
diff --git a/elpa/org-9.3.2/ob-latex.el b/elpa/org-9.3.3/ob-latex.el
similarity index 100%
rename from elpa/org-9.3.2/ob-latex.el
rename to elpa/org-9.3.3/ob-latex.el
diff --git a/elpa/org-9.3.2/ob-latex.elc b/elpa/org-9.3.3/ob-latex.elc
similarity index 100%
rename from elpa/org-9.3.2/ob-latex.elc
rename to elpa/org-9.3.3/ob-latex.elc
diff --git a/elpa/org-9.3.2/ob-ledger.el b/elpa/org-9.3.3/ob-ledger.el
similarity index 100%
rename from elpa/org-9.3.2/ob-ledger.el
rename to elpa/org-9.3.3/ob-ledger.el
diff --git a/elpa/org-9.3.2/ob-ledger.elc b/elpa/org-9.3.3/ob-ledger.elc
similarity index 100%
rename from elpa/org-9.3.2/ob-ledger.elc
rename to elpa/org-9.3.3/ob-ledger.elc
diff --git a/elpa/org-9.3.2/ob-lilypond.el b/elpa/org-9.3.3/ob-lilypond.el
similarity index 100%
rename from elpa/org-9.3.2/ob-lilypond.el
rename to elpa/org-9.3.3/ob-lilypond.el
diff --git a/elpa/org-9.3.2/ob-lilypond.elc b/elpa/org-9.3.3/ob-lilypond.elc
similarity index 100%
rename from elpa/org-9.3.2/ob-lilypond.elc
rename to elpa/org-9.3.3/ob-lilypond.elc
diff --git a/elpa/org-9.3.2/ob-lisp.el b/elpa/org-9.3.3/ob-lisp.el
similarity index 100%
rename from elpa/org-9.3.2/ob-lisp.el
rename to elpa/org-9.3.3/ob-lisp.el
diff --git a/elpa/org-9.3.2/ob-lisp.elc b/elpa/org-9.3.3/ob-lisp.elc
similarity index 100%
rename from elpa/org-9.3.2/ob-lisp.elc
rename to elpa/org-9.3.3/ob-lisp.elc
diff --git a/elpa/org-9.3.2/ob-lob.el b/elpa/org-9.3.3/ob-lob.el
similarity index 100%
rename from elpa/org-9.3.2/ob-lob.el
rename to elpa/org-9.3.3/ob-lob.el
diff --git a/elpa/org-9.3.2/ob-lob.elc b/elpa/org-9.3.3/ob-lob.elc
similarity index 100%
rename from elpa/org-9.3.2/ob-lob.elc
rename to elpa/org-9.3.3/ob-lob.elc
diff --git a/elpa/org-9.3.2/ob-lua.el b/elpa/org-9.3.3/ob-lua.el
similarity index 100%
rename from elpa/org-9.3.2/ob-lua.el
rename to elpa/org-9.3.3/ob-lua.el
diff --git a/elpa/org-9.3.2/ob-lua.elc b/elpa/org-9.3.3/ob-lua.elc
similarity index 100%
rename from elpa/org-9.3.2/ob-lua.elc
rename to elpa/org-9.3.3/ob-lua.elc
diff --git a/elpa/org-9.3.2/ob-makefile.el b/elpa/org-9.3.3/ob-makefile.el
similarity index 100%
rename from elpa/org-9.3.2/ob-makefile.el
rename to elpa/org-9.3.3/ob-makefile.el
diff --git a/elpa/org-9.3.2/ob-makefile.elc b/elpa/org-9.3.3/ob-makefile.elc
similarity index 100%
rename from elpa/org-9.3.2/ob-makefile.elc
rename to elpa/org-9.3.3/ob-makefile.elc
diff --git a/elpa/org-9.3.2/ob-matlab.el b/elpa/org-9.3.3/ob-matlab.el
similarity index 100%
rename from elpa/org-9.3.2/ob-matlab.el
rename to elpa/org-9.3.3/ob-matlab.el
diff --git a/elpa/org-9.3.2/ob-matlab.elc b/elpa/org-9.3.3/ob-matlab.elc
similarity index 100%
rename from elpa/org-9.3.2/ob-matlab.elc
rename to elpa/org-9.3.3/ob-matlab.elc
diff --git a/elpa/org-9.3.2/ob-maxima.el b/elpa/org-9.3.3/ob-maxima.el
similarity index 100%
rename from elpa/org-9.3.2/ob-maxima.el
rename to elpa/org-9.3.3/ob-maxima.el
diff --git a/elpa/org-9.3.2/ob-maxima.elc b/elpa/org-9.3.3/ob-maxima.elc
similarity index 100%
rename from elpa/org-9.3.2/ob-maxima.elc
rename to elpa/org-9.3.3/ob-maxima.elc
diff --git a/elpa/org-9.3.2/ob-mscgen.el b/elpa/org-9.3.3/ob-mscgen.el
similarity index 100%
rename from elpa/org-9.3.2/ob-mscgen.el
rename to elpa/org-9.3.3/ob-mscgen.el
diff --git a/elpa/org-9.3.2/ob-mscgen.elc b/elpa/org-9.3.3/ob-mscgen.elc
similarity index 100%
rename from elpa/org-9.3.2/ob-mscgen.elc
rename to elpa/org-9.3.3/ob-mscgen.elc
diff --git a/elpa/org-9.3.2/ob-ocaml.el b/elpa/org-9.3.3/ob-ocaml.el
similarity index 100%
rename from elpa/org-9.3.2/ob-ocaml.el
rename to elpa/org-9.3.3/ob-ocaml.el
diff --git a/elpa/org-9.3.2/ob-ocaml.elc b/elpa/org-9.3.3/ob-ocaml.elc
similarity index 100%
rename from elpa/org-9.3.2/ob-ocaml.elc
rename to elpa/org-9.3.3/ob-ocaml.elc
diff --git a/elpa/org-9.3.2/ob-octave.el b/elpa/org-9.3.3/ob-octave.el
similarity index 100%
rename from elpa/org-9.3.2/ob-octave.el
rename to elpa/org-9.3.3/ob-octave.el
diff --git a/elpa/org-9.3.2/ob-octave.elc b/elpa/org-9.3.3/ob-octave.elc
similarity index 100%
rename from elpa/org-9.3.2/ob-octave.elc
rename to elpa/org-9.3.3/ob-octave.elc
diff --git a/elpa/org-9.3.2/ob-org.el b/elpa/org-9.3.3/ob-org.el
similarity index 100%
rename from elpa/org-9.3.2/ob-org.el
rename to elpa/org-9.3.3/ob-org.el
diff --git a/elpa/org-9.3.2/ob-org.elc b/elpa/org-9.3.3/ob-org.elc
similarity index 100%
rename from elpa/org-9.3.2/ob-org.elc
rename to elpa/org-9.3.3/ob-org.elc
diff --git a/elpa/org-9.3.2/ob-perl.el b/elpa/org-9.3.3/ob-perl.el
similarity index 100%
rename from elpa/org-9.3.2/ob-perl.el
rename to elpa/org-9.3.3/ob-perl.el
diff --git a/elpa/org-9.3.2/ob-perl.elc b/elpa/org-9.3.3/ob-perl.elc
similarity index 100%
rename from elpa/org-9.3.2/ob-perl.elc
rename to elpa/org-9.3.3/ob-perl.elc
diff --git a/elpa/org-9.3.2/ob-picolisp.el b/elpa/org-9.3.3/ob-picolisp.el
similarity index 100%
rename from elpa/org-9.3.2/ob-picolisp.el
rename to elpa/org-9.3.3/ob-picolisp.el
diff --git a/elpa/org-9.3.2/ob-picolisp.elc b/elpa/org-9.3.3/ob-picolisp.elc
similarity index 100%
rename from elpa/org-9.3.2/ob-picolisp.elc
rename to elpa/org-9.3.3/ob-picolisp.elc
diff --git a/elpa/org-9.3.2/ob-plantuml.el b/elpa/org-9.3.3/ob-plantuml.el
similarity index 100%
rename from elpa/org-9.3.2/ob-plantuml.el
rename to elpa/org-9.3.3/ob-plantuml.el
diff --git a/elpa/org-9.3.2/ob-plantuml.elc b/elpa/org-9.3.3/ob-plantuml.elc
similarity index 100%
rename from elpa/org-9.3.2/ob-plantuml.elc
rename to elpa/org-9.3.3/ob-plantuml.elc
diff --git a/elpa/org-9.3.2/ob-processing.el b/elpa/org-9.3.3/ob-processing.el
similarity index 100%
rename from elpa/org-9.3.2/ob-processing.el
rename to elpa/org-9.3.3/ob-processing.el
diff --git a/elpa/org-9.3.2/ob-processing.elc b/elpa/org-9.3.3/ob-processing.elc
similarity index 100%
rename from elpa/org-9.3.2/ob-processing.elc
rename to elpa/org-9.3.3/ob-processing.elc
diff --git a/elpa/org-9.3.2/ob-python.el b/elpa/org-9.3.3/ob-python.el
similarity index 100%
rename from elpa/org-9.3.2/ob-python.el
rename to elpa/org-9.3.3/ob-python.el
diff --git a/elpa/org-9.3.2/ob-python.elc b/elpa/org-9.3.3/ob-python.elc
similarity index 90%
rename from elpa/org-9.3.2/ob-python.elc
rename to elpa/org-9.3.3/ob-python.elc
index f98f1a20..4a288f9e 100644
Binary files a/elpa/org-9.3.2/ob-python.elc and b/elpa/org-9.3.3/ob-python.elc differ
diff --git a/elpa/org-9.3.2/ob-ref.el b/elpa/org-9.3.3/ob-ref.el
similarity index 100%
rename from elpa/org-9.3.2/ob-ref.el
rename to elpa/org-9.3.3/ob-ref.el
diff --git a/elpa/org-9.3.2/ob-ref.elc b/elpa/org-9.3.3/ob-ref.elc
similarity index 100%
rename from elpa/org-9.3.2/ob-ref.elc
rename to elpa/org-9.3.3/ob-ref.elc
diff --git a/elpa/org-9.3.2/ob-ruby.el b/elpa/org-9.3.3/ob-ruby.el
similarity index 100%
rename from elpa/org-9.3.2/ob-ruby.el
rename to elpa/org-9.3.3/ob-ruby.el
diff --git a/elpa/org-9.3.2/ob-ruby.elc b/elpa/org-9.3.3/ob-ruby.elc
similarity index 100%
rename from elpa/org-9.3.2/ob-ruby.elc
rename to elpa/org-9.3.3/ob-ruby.elc
diff --git a/elpa/org-9.3.2/ob-sass.el b/elpa/org-9.3.3/ob-sass.el
similarity index 100%
rename from elpa/org-9.3.2/ob-sass.el
rename to elpa/org-9.3.3/ob-sass.el
diff --git a/elpa/org-9.3.2/ob-sass.elc b/elpa/org-9.3.3/ob-sass.elc
similarity index 100%
rename from elpa/org-9.3.2/ob-sass.elc
rename to elpa/org-9.3.3/ob-sass.elc
diff --git a/elpa/org-9.3.2/ob-scheme.el b/elpa/org-9.3.3/ob-scheme.el
similarity index 100%
rename from elpa/org-9.3.2/ob-scheme.el
rename to elpa/org-9.3.3/ob-scheme.el
diff --git a/elpa/org-9.3.2/ob-scheme.elc b/elpa/org-9.3.3/ob-scheme.elc
similarity index 100%
rename from elpa/org-9.3.2/ob-scheme.elc
rename to elpa/org-9.3.3/ob-scheme.elc
diff --git a/elpa/org-9.3.2/ob-screen.el b/elpa/org-9.3.3/ob-screen.el
similarity index 100%
rename from elpa/org-9.3.2/ob-screen.el
rename to elpa/org-9.3.3/ob-screen.el
diff --git a/elpa/org-9.3.2/ob-screen.elc b/elpa/org-9.3.3/ob-screen.elc
similarity index 100%
rename from elpa/org-9.3.2/ob-screen.elc
rename to elpa/org-9.3.3/ob-screen.elc
diff --git a/elpa/org-9.3.2/ob-sed.el b/elpa/org-9.3.3/ob-sed.el
similarity index 100%
rename from elpa/org-9.3.2/ob-sed.el
rename to elpa/org-9.3.3/ob-sed.el
diff --git a/elpa/org-9.3.2/ob-sed.elc b/elpa/org-9.3.3/ob-sed.elc
similarity index 100%
rename from elpa/org-9.3.2/ob-sed.elc
rename to elpa/org-9.3.3/ob-sed.elc
diff --git a/elpa/org-9.3.2/ob-shell.el b/elpa/org-9.3.3/ob-shell.el
similarity index 100%
rename from elpa/org-9.3.2/ob-shell.el
rename to elpa/org-9.3.3/ob-shell.el
diff --git a/elpa/org-9.3.2/ob-shell.elc b/elpa/org-9.3.3/ob-shell.elc
similarity index 100%
rename from elpa/org-9.3.2/ob-shell.elc
rename to elpa/org-9.3.3/ob-shell.elc
diff --git a/elpa/org-9.3.2/ob-shen.el b/elpa/org-9.3.3/ob-shen.el
similarity index 100%
rename from elpa/org-9.3.2/ob-shen.el
rename to elpa/org-9.3.3/ob-shen.el
diff --git a/elpa/org-9.3.2/ob-shen.elc b/elpa/org-9.3.3/ob-shen.elc
similarity index 100%
rename from elpa/org-9.3.2/ob-shen.elc
rename to elpa/org-9.3.3/ob-shen.elc
diff --git a/elpa/org-9.3.2/ob-sql.el b/elpa/org-9.3.3/ob-sql.el
similarity index 100%
rename from elpa/org-9.3.2/ob-sql.el
rename to elpa/org-9.3.3/ob-sql.el
diff --git a/elpa/org-9.3.2/ob-sql.elc b/elpa/org-9.3.3/ob-sql.elc
similarity index 100%
rename from elpa/org-9.3.2/ob-sql.elc
rename to elpa/org-9.3.3/ob-sql.elc
diff --git a/elpa/org-9.3.2/ob-sqlite.el b/elpa/org-9.3.3/ob-sqlite.el
similarity index 100%
rename from elpa/org-9.3.2/ob-sqlite.el
rename to elpa/org-9.3.3/ob-sqlite.el
diff --git a/elpa/org-9.3.2/ob-sqlite.elc b/elpa/org-9.3.3/ob-sqlite.elc
similarity index 100%
rename from elpa/org-9.3.2/ob-sqlite.elc
rename to elpa/org-9.3.3/ob-sqlite.elc
diff --git a/elpa/org-9.3.2/ob-stan.el b/elpa/org-9.3.3/ob-stan.el
similarity index 100%
rename from elpa/org-9.3.2/ob-stan.el
rename to elpa/org-9.3.3/ob-stan.el
diff --git a/elpa/org-9.3.2/ob-stan.elc b/elpa/org-9.3.3/ob-stan.elc
similarity index 100%
rename from elpa/org-9.3.2/ob-stan.elc
rename to elpa/org-9.3.3/ob-stan.elc
diff --git a/elpa/org-9.3.2/ob-table.el b/elpa/org-9.3.3/ob-table.el
similarity index 100%
rename from elpa/org-9.3.2/ob-table.el
rename to elpa/org-9.3.3/ob-table.el
diff --git a/elpa/org-9.3.2/ob-table.elc b/elpa/org-9.3.3/ob-table.elc
similarity index 100%
rename from elpa/org-9.3.2/ob-table.elc
rename to elpa/org-9.3.3/ob-table.elc
diff --git a/elpa/org-9.3.2/ob-tangle.el b/elpa/org-9.3.3/ob-tangle.el
similarity index 100%
rename from elpa/org-9.3.2/ob-tangle.el
rename to elpa/org-9.3.3/ob-tangle.el
diff --git a/elpa/org-9.3.2/ob-tangle.elc b/elpa/org-9.3.3/ob-tangle.elc
similarity index 100%
rename from elpa/org-9.3.2/ob-tangle.elc
rename to elpa/org-9.3.3/ob-tangle.elc
diff --git a/elpa/org-9.3.2/ob-vala.el b/elpa/org-9.3.3/ob-vala.el
similarity index 100%
rename from elpa/org-9.3.2/ob-vala.el
rename to elpa/org-9.3.3/ob-vala.el
diff --git a/elpa/org-9.3.2/ob-vala.elc b/elpa/org-9.3.3/ob-vala.elc
similarity index 100%
rename from elpa/org-9.3.2/ob-vala.elc
rename to elpa/org-9.3.3/ob-vala.elc
diff --git a/elpa/org-9.3.2/ob.el b/elpa/org-9.3.3/ob.el
similarity index 100%
rename from elpa/org-9.3.2/ob.el
rename to elpa/org-9.3.3/ob.el
diff --git a/elpa/org-9.3.2/ob.elc b/elpa/org-9.3.3/ob.elc
similarity index 100%
rename from elpa/org-9.3.2/ob.elc
rename to elpa/org-9.3.3/ob.elc
diff --git a/elpa/org-9.3.2/ol-bbdb.el b/elpa/org-9.3.3/ol-bbdb.el
similarity index 100%
rename from elpa/org-9.3.2/ol-bbdb.el
rename to elpa/org-9.3.3/ol-bbdb.el
diff --git a/elpa/org-9.3.2/ol-bbdb.elc b/elpa/org-9.3.3/ol-bbdb.elc
similarity index 100%
rename from elpa/org-9.3.2/ol-bbdb.elc
rename to elpa/org-9.3.3/ol-bbdb.elc
diff --git a/elpa/org-9.3.2/ol-bibtex.el b/elpa/org-9.3.3/ol-bibtex.el
similarity index 100%
rename from elpa/org-9.3.2/ol-bibtex.el
rename to elpa/org-9.3.3/ol-bibtex.el
diff --git a/elpa/org-9.3.2/ol-bibtex.elc b/elpa/org-9.3.3/ol-bibtex.elc
similarity index 100%
rename from elpa/org-9.3.2/ol-bibtex.elc
rename to elpa/org-9.3.3/ol-bibtex.elc
diff --git a/elpa/org-9.3.2/ol-docview.el b/elpa/org-9.3.3/ol-docview.el
similarity index 100%
rename from elpa/org-9.3.2/ol-docview.el
rename to elpa/org-9.3.3/ol-docview.el
diff --git a/elpa/org-9.3.2/ol-docview.elc b/elpa/org-9.3.3/ol-docview.elc
similarity index 100%
rename from elpa/org-9.3.2/ol-docview.elc
rename to elpa/org-9.3.3/ol-docview.elc
diff --git a/elpa/org-9.3.2/ol-eshell.el b/elpa/org-9.3.3/ol-eshell.el
similarity index 100%
rename from elpa/org-9.3.2/ol-eshell.el
rename to elpa/org-9.3.3/ol-eshell.el
diff --git a/elpa/org-9.3.2/ol-eshell.elc b/elpa/org-9.3.3/ol-eshell.elc
similarity index 100%
rename from elpa/org-9.3.2/ol-eshell.elc
rename to elpa/org-9.3.3/ol-eshell.elc
diff --git a/elpa/org-9.3.2/ol-eww.el b/elpa/org-9.3.3/ol-eww.el
similarity index 100%
rename from elpa/org-9.3.2/ol-eww.el
rename to elpa/org-9.3.3/ol-eww.el
diff --git a/elpa/org-9.3.2/ol-eww.elc b/elpa/org-9.3.3/ol-eww.elc
similarity index 100%
rename from elpa/org-9.3.2/ol-eww.elc
rename to elpa/org-9.3.3/ol-eww.elc
diff --git a/elpa/org-9.3.2/ol-gnus.el b/elpa/org-9.3.3/ol-gnus.el
similarity index 100%
rename from elpa/org-9.3.2/ol-gnus.el
rename to elpa/org-9.3.3/ol-gnus.el
diff --git a/elpa/org-9.3.2/ol-gnus.elc b/elpa/org-9.3.3/ol-gnus.elc
similarity index 100%
rename from elpa/org-9.3.2/ol-gnus.elc
rename to elpa/org-9.3.3/ol-gnus.elc
diff --git a/elpa/org-9.3.2/ol-info.el b/elpa/org-9.3.3/ol-info.el
similarity index 100%
rename from elpa/org-9.3.2/ol-info.el
rename to elpa/org-9.3.3/ol-info.el
diff --git a/elpa/org-9.3.2/ol-info.elc b/elpa/org-9.3.3/ol-info.elc
similarity index 100%
rename from elpa/org-9.3.2/ol-info.elc
rename to elpa/org-9.3.3/ol-info.elc
diff --git a/elpa/org-9.3.2/ol-irc.el b/elpa/org-9.3.3/ol-irc.el
similarity index 100%
rename from elpa/org-9.3.2/ol-irc.el
rename to elpa/org-9.3.3/ol-irc.el
diff --git a/elpa/org-9.3.2/ol-irc.elc b/elpa/org-9.3.3/ol-irc.elc
similarity index 100%
rename from elpa/org-9.3.2/ol-irc.elc
rename to elpa/org-9.3.3/ol-irc.elc
diff --git a/elpa/org-9.3.2/ol-mhe.el b/elpa/org-9.3.3/ol-mhe.el
similarity index 100%
rename from elpa/org-9.3.2/ol-mhe.el
rename to elpa/org-9.3.3/ol-mhe.el
diff --git a/elpa/org-9.3.2/ol-mhe.elc b/elpa/org-9.3.3/ol-mhe.elc
similarity index 100%
rename from elpa/org-9.3.2/ol-mhe.elc
rename to elpa/org-9.3.3/ol-mhe.elc
diff --git a/elpa/org-9.3.2/ol-rmail.el b/elpa/org-9.3.3/ol-rmail.el
similarity index 100%
rename from elpa/org-9.3.2/ol-rmail.el
rename to elpa/org-9.3.3/ol-rmail.el
diff --git a/elpa/org-9.3.2/ol-rmail.elc b/elpa/org-9.3.3/ol-rmail.elc
similarity index 100%
rename from elpa/org-9.3.2/ol-rmail.elc
rename to elpa/org-9.3.3/ol-rmail.elc
diff --git a/elpa/org-9.3.2/ol-w3m.el b/elpa/org-9.3.3/ol-w3m.el
similarity index 100%
rename from elpa/org-9.3.2/ol-w3m.el
rename to elpa/org-9.3.3/ol-w3m.el
diff --git a/elpa/org-9.3.2/ol-w3m.elc b/elpa/org-9.3.3/ol-w3m.elc
similarity index 100%
rename from elpa/org-9.3.2/ol-w3m.elc
rename to elpa/org-9.3.3/ol-w3m.elc
diff --git a/elpa/org-9.3.2/ol.el b/elpa/org-9.3.3/ol.el
similarity index 100%
rename from elpa/org-9.3.2/ol.el
rename to elpa/org-9.3.3/ol.el
diff --git a/elpa/org-9.3.2/ol.elc b/elpa/org-9.3.3/ol.elc
similarity index 100%
rename from elpa/org-9.3.2/ol.elc
rename to elpa/org-9.3.3/ol.elc
diff --git a/elpa/org-9.3.2/org b/elpa/org-9.3.3/org
similarity index 98%
rename from elpa/org-9.3.2/org
rename to elpa/org-9.3.3/org
index 197a4953..03fa52e5 100644
--- a/elpa/org-9.3.2/org
+++ b/elpa/org-9.3.3/org
@@ -8663,9 +8663,6 @@ Remote editing
      priority character.  If you reply with ‘<SPC>’, the priority cookie
      is removed from the entry.
 
-‘P’ (‘org-agenda-show-priority’)
-     Display weighted priority of current item.
-
 ‘+’ or ‘S-<UP>’ (‘org-agenda-priority-up’)
      Increase the priority of the current item.  The priority is changed
      in the original buffer, but the agenda is not resorted.  Use the
@@ -18952,7 +18949,7 @@ D Main Index
 * agenda:                                Weekly/daily agenda. (line   6)
 * agenda dispatcher:                     Agenda Dispatcher.   (line   6)
 * agenda files:                          Agenda Files.        (line   6)
-* agenda files, removing buffers:        Agenda Commands.     (line 496)
+* agenda files, removing buffers:        Agenda Commands.     (line 493)
 * agenda filtering:                      Filtering/limiting agenda items.
                                                               (line  20)
 * agenda views:                          Agenda Views.        (line   6)
@@ -19137,7 +19134,7 @@ D Main Index
 * calculations, in tables:               Built-in Table Editor.
                                                               (line 179)
 * calculations, in tables <1>:           The Spreadsheet.     (line   6)
-* calendar commands, from agenda:        Agenda Commands.     (line 446)
+* calendar commands, from agenda:        Agenda Commands.     (line 443)
 * calendar integration:                  Weekly/daily agenda. (line  32)
 * calendar, for selecting date:          The date/time prompt.
                                                               (line  75)
@@ -19154,7 +19151,7 @@ D Main Index
 * capture <1>:                           Capture.             (line   6)
 * capture protocol:                      The capture protocol.
                                                               (line   6)
-* capturing, from agenda:                Agenda Commands.     (line 345)
+* capturing, from agenda:                Agenda Commands.     (line 342)
 * category:                              Categories.          (line   6)
 * category filtering, in agenda:         Filtering/limiting agenda items.
                                                               (line  20)
@@ -19313,7 +19310,7 @@ D Main Index
 * DESCRIPTION, property:                 Headings and sectioning structure.
                                                               (line  24)
 * DESCRIPTION, property <1>:             iCalendar Export.    (line  51)
-* diary entries, creating from agenda:   Agenda Commands.     (line 455)
+* diary entries, creating from agenda:   Agenda Commands.     (line 452)
 * diary integration:                     Weekly/daily agenda. (line  32)
 * diary style timestamps:                Timestamps.          (line  34)
 * dictionary word completion:            Completion.          (line   6)
@@ -19905,7 +19902,7 @@ D Main Index
                                                               (line  53)
 * relative timer:                        Timers.              (line   6)
 * reminders:                             Weekly/daily agenda. (line 125)
-* remote editing, bulk, from agenda:     Agenda Commands.     (line 352)
+* remote editing, bulk, from agenda:     Agenda Commands.     (line 349)
 * remote editing, from agenda:           Agenda Commands.     (line 223)
 * remote editing, undo:                  Agenda Commands.     (line 227)
 * remote references:                     References.          (line 134)
@@ -20294,13 +20291,13 @@ E Key Index
 * ! (Agenda dispatcher):                 Stuck projects.      (line  17)
 * # (Agenda dispatcher):                 Stuck projects.      (line  14)
 * $:                                     Agenda Commands.     (line 265)
-* %:                                     Agenda Commands.     (line 379)
+* %:                                     Agenda Commands.     (line 376)
 * ':                                     CDLaTeX mode.        (line  57)
-* *:                                     Agenda Commands.     (line 359)
+* *:                                     Agenda Commands.     (line 356)
 * * (Agenda dispatcher):                 Agenda Dispatcher.   (line  53)
-* +:                                     Agenda Commands.     (line 287)
+* +:                                     Agenda Commands.     (line 284)
 * ,:                                     Agenda Commands.     (line 279)
-* -:                                     Agenda Commands.     (line 292)
+* -:                                     Agenda Commands.     (line 289)
 * .:                                     Agenda Commands.     (line 118)
 * / (Agenda dispatcher):                 Agenda Dispatcher.   (line  30)
 * 1..9,0:                                Using column view.   (line  35)
@@ -20313,7 +20310,7 @@ E Key Index
 * >:                                     Using column view.   (line  66)
 * > <1>:                                 The date/time prompt.
                                                               (line  81)
-* > <2>:                                 Agenda Commands.     (line 328)
+* > <2>:                                 Agenda Commands.     (line 325)
 * ? (Agenda dispatcher):                 Pulling from the mobile application.
                                                               (line  39)
 * [:                                     Agenda Commands.     (line 142)
@@ -20325,11 +20322,11 @@ E Key Index
 * a <1>:                                 Agenda Commands.     (line 252)
 * a (Agenda dispatcher):                 Weekly/daily agenda. (line  10)
 * b:                                     Agenda Commands.     (line 115)
-* B:                                     Agenda Commands.     (line 383)
+* B:                                     Agenda Commands.     (line 380)
 * C:                                     Resolving idle time. (line  46)
-* c:                                     Agenda Commands.     (line 447)
-* c <1>:                                 Agenda Commands.     (line 450)
-* C <1>:                                 Agenda Commands.     (line 481)
+* c:                                     Agenda Commands.     (line 444)
+* c <1>:                                 Agenda Commands.     (line 447)
+* C <1>:                                 Agenda Commands.     (line 478)
 * C (Agenda dispatcher):                 Storing searches.    (line  11)
 * C (Capture menu:                       Capture templates.   (line  11)
 * C-#:                                   Advanced features.   (line  11)
@@ -20386,7 +20383,7 @@ E Key Index
 * C-c C-,:                               Structure Templates. (line  11)
 * C-c C-a:                               Attachment defaults and dispatcher.
                                                               (line  19)
-* C-c C-a <1>:                           Agenda Commands.     (line 300)
+* C-c C-a <1>:                           Agenda Commands.     (line 297)
 * C-c C-a a:                             Attachment defaults and dispatcher.
                                                               (line  24)
 * C-c C-a b:                             Attachment defaults and dispatcher.
@@ -20456,7 +20453,7 @@ E Key Index
 * C-c C-c s:                             Property Syntax.     (line  98)
 * C-c C-d:                               Inserting deadline/schedule.
                                                               (line  10)
-* C-c C-d <1>:                           Agenda Commands.     (line 307)
+* C-c C-d <1>:                           Agenda Commands.     (line 304)
 * C-c C-e:                               The Export Dispatcher.
                                                               (line  16)
 * C-c C-e c a:                           iCalendar Export.    (line  43)
@@ -20545,7 +20542,7 @@ E Key Index
                                                               (line  52)
 * C-c C-s:                               Inserting deadline/schedule.
                                                               (line  18)
-* C-c C-s <1>:                           Agenda Commands.     (line 303)
+* C-c C-s <1>:                           Agenda Commands.     (line 300)
 * C-c C-t:                               TODO Basics.         (line  14)
 * C-c C-t <1>:                           Clocking commands.   (line  71)
 * C-c C-u:                               Motion.              (line  21)
@@ -20724,7 +20721,7 @@ E Key Index
 * C-c C-y:                               Creating Timestamps. (line  62)
 * C-c C-y <1>:                           Clocking commands.   (line  53)
 * C-c C-z:                               Drawers.             (line  39)
-* C-c C-z <1>:                           Agenda Commands.     (line 295)
+* C-c C-z <1>:                           Agenda Commands.     (line 292)
 * C-c M-w:                               Refile and Copy.     (line  51)
 * C-c RET:                               Built-in Table Editor.
                                                               (line 129)
@@ -20833,19 +20830,19 @@ E Key Index
 * g:                                     Using column view.   (line  22)
 * G:                                     Agenda Commands.     (line 181)
 * g <1>:                                 Agenda Commands.     (line 186)
-* H:                                     Agenda Commands.     (line 485)
-* I:                                     Agenda Commands.     (line 332)
-* i:                                     Agenda Commands.     (line 454)
+* H:                                     Agenda Commands.     (line 482)
+* I:                                     Agenda Commands.     (line 329)
+* i:                                     Agenda Commands.     (line 451)
 * j:                                     Agenda Commands.     (line 121)
 * J:                                     Agenda Commands.     (line 124)
-* J <1>:                                 Agenda Commands.     (line 342)
+* J <1>:                                 Agenda Commands.     (line 339)
 * k:                                     Resolving idle time. (line  23)
 * K:                                     Resolving idle time. (line  29)
-* k <1>:                                 Agenda Commands.     (line 345)
+* k <1>:                                 Agenda Commands.     (line 342)
 * k c (Agenda):                          Using capture.       (line  33)
 * l:                                     Agenda Commands.     (line 131)
-* m:                                     Agenda Commands.     (line 353)
-* M:                                     Agenda Commands.     (line 472)
+* m:                                     Agenda Commands.     (line 350)
+* M:                                     Agenda Commands.     (line 469)
 * m (Agenda dispatcher):                 Tag Searches.        (line  15)
 * M (Agenda dispatcher):                 Tag Searches.        (line  19)
 * m (Agenda dispatcher) <1>:             Property Searches.   (line  15)
@@ -20854,7 +20851,7 @@ E Key Index
                                                               (line  13)
 * M (Agenda dispatcher) <2>:             Matching tags and properties.
                                                               (line  21)
-* M-*:                                   Agenda Commands.     (line 375)
+* M-*:                                   Agenda Commands.     (line 372)
 * M-a:                                   Built-in Table Editor.
                                                               (line  78)
 * M-DOWN:                                Structure Editing.   (line  58)
@@ -20876,7 +20873,7 @@ E Key Index
 * M-LEFT <1>:                            Plain Lists.         (line 108)
 * M-LEFT <2>:                            Built-in Table Editor.
                                                               (line  88)
-* M-m:                                   Agenda Commands.     (line 371)
+* M-m:                                   Agenda Commands.     (line 368)
 * M-RET:                                 Structure Editing.   (line   7)
 * M-RET <1>:                             Plain Lists.         (line  83)
 * M-RET <2>:                             Built-in Table Editor.
@@ -20938,13 +20935,12 @@ E Key Index
 * n:                                     Using column view.   (line  39)
 * n <1>:                                 Agenda Commands.     (line  20)
 * o:                                     Agenda Commands.     (line  68)
-* O:                                     Agenda Commands.     (line 336)
+* O:                                     Agenda Commands.     (line 333)
 * p:                                     Using column view.   (line  39)
 * p <1>:                                 Agenda Commands.     (line  23)
-* P:                                     Agenda Commands.     (line 284)
 * q:                                     Setting Tags.        (line 123)
 * q <1>:                                 Using column view.   (line  26)
-* q <2>:                                 Agenda Commands.     (line 491)
+* q <2>:                                 Agenda Commands.     (line 488)
 * r:                                     Using column view.   (line  22)
 * r <1>:                                 Global TODO list.    (line  25)
 * R:                                     Agenda Commands.     (line 154)
@@ -20959,7 +20955,7 @@ E Key Index
 * s:                                     Resolving idle time. (line  35)
 * S:                                     Resolving idle time. (line  40)
 * s <1>:                                 Agenda Commands.     (line 193)
-* S <1>:                                 Agenda Commands.     (line 476)
+* S <1>:                                 Agenda Commands.     (line 473)
 * s (Agenda dispatcher):                 Agenda Dispatcher.   (line  25)
 * s (Agenda dispatcher) <1>:             Search view.         (line  10)
 * S-DOWN:                                Plain Lists.         (line  95)
@@ -20971,7 +20967,7 @@ E Key Index
 * S-DOWN <4>:                            Creating Timestamps. (line  50)
 * S-DOWN <5>:                            The date/time prompt.
                                                               (line  81)
-* S-DOWN <6>:                            Agenda Commands.     (line 292)
+* S-DOWN <6>:                            Agenda Commands.     (line 289)
 * S-LEFT:                                Plain Lists.         (line 154)
 * S-LEFT <1>:                            Built-in Table Editor.
                                                               (line 115)
@@ -20986,7 +20982,7 @@ E Key Index
 * S-LEFT <8>:                            The date/time prompt.
                                                               (line  81)
 * S-LEFT <9>:                            The clock table.     (line  26)
-* S-LEFT <10>:                           Agenda Commands.     (line 324)
+* S-LEFT <10>:                           Agenda Commands.     (line 321)
 * S-M-DOWN:                              Clocking commands.   (line  64)
 * S-M-LEFT:                              Using column view.   (line  72)
 * S-M-RET:                               TODO Basics.         (line  54)
@@ -21008,7 +21004,7 @@ E Key Index
 * S-RIGHT <8>:                           The date/time prompt.
                                                               (line  81)
 * S-RIGHT <9>:                           The clock table.     (line  26)
-* S-RIGHT <10>:                          Agenda Commands.     (line 311)
+* S-RIGHT <10>:                          Agenda Commands.     (line 308)
 * S-TAB:                                 Global and local cycling.
                                                               (line  20)
 * S-TAB <1>:                             Built-in Table Editor.
@@ -21022,7 +21018,7 @@ E Key Index
 * S-UP <4>:                              Creating Timestamps. (line  50)
 * S-UP <5>:                              The date/time prompt.
                                                               (line  81)
-* S-UP <6>:                              Agenda Commands.     (line 287)
+* S-UP <6>:                              Agenda Commands.     (line 284)
 * SPC:                                   Setting Tags.        (line 114)
 * SPC <1>:                               Agenda Commands.     (line  29)
 * t:                                     Agenda Commands.     (line 231)
@@ -21041,8 +21037,8 @@ E Key Index
 * TAB <5>:                               Setting Tags.        (line 108)
 * TAB <6>:                               Agenda Commands.     (line  36)
 * TAB <7>:                               CDLaTeX mode.        (line  29)
-* u:                                     Agenda Commands.     (line 363)
-* U:                                     Agenda Commands.     (line 367)
+* u:                                     Agenda Commands.     (line 360)
+* U:                                     Agenda Commands.     (line 364)
 * v:                                     Using column view.   (line  52)
 * v a:                                   Agenda Commands.     (line 146)
 * v A:                                   Agenda Commands.     (line 151)
@@ -21058,9 +21054,9 @@ E Key Index
 * v y:                                   Agenda Commands.     (line 101)
 * v [:                                   Agenda Commands.     (line 142)
 * w:                                     Agenda Commands.     (line  81)
-* X:                                     Agenda Commands.     (line 339)
-* x:                                     Agenda Commands.     (line 495)
-* z:                                     Agenda Commands.     (line 295)
+* X:                                     Agenda Commands.     (line 336)
+* x:                                     Agenda Commands.     (line 492)
+* z:                                     Agenda Commands.     (line 292)
 
 
 File: org,  Node: Command and Function Index,  Next: Variable Index,  Prev: Key Index,  Up: Top
@@ -21076,41 +21072,41 @@ F Command and Function Index
 * next-error:                            Sparse Trees.        (line  32)
 * or-clock-goto:                         Clocking commands.   (line  79)
 * org-agenda:                            Activation.          (line  13)
-* org-agenda-add-note:                   Agenda Commands.     (line 295)
+* org-agenda-add-note:                   Agenda Commands.     (line 292)
 * org-agenda-archive:                    Agenda Commands.     (line 265)
 * org-agenda-archive-default-with-confirmation: Agenda Commands.
                                                               (line 252)
 * org-agenda-archive-to-archive-sibling: Agenda Commands.     (line 261)
 * org-agenda-archives-mode:              Agenda Commands.     (line 146)
-* org-agenda-bulk-action:                Agenda Commands.     (line 383)
-* org-agenda-bulk-mark:                  Agenda Commands.     (line 353)
-* org-agenda-bulk-mark-all:              Agenda Commands.     (line 359)
-* org-agenda-bulk-mark-regexp:           Agenda Commands.     (line 379)
-* org-agenda-bulk-remove-all-marks:      Agenda Commands.     (line 367)
-* org-agenda-bulk-toggle:                Agenda Commands.     (line 371)
-* org-agenda-bulk-toggle-all:            Agenda Commands.     (line 375)
-* org-agenda-bulk-unmark:                Agenda Commands.     (line 363)
-* org-agenda-capture:                    Agenda Commands.     (line 345)
-* org-agenda-clock-cancel:               Agenda Commands.     (line 339)
+* org-agenda-bulk-action:                Agenda Commands.     (line 380)
+* org-agenda-bulk-mark:                  Agenda Commands.     (line 350)
+* org-agenda-bulk-mark-all:              Agenda Commands.     (line 356)
+* org-agenda-bulk-mark-regexp:           Agenda Commands.     (line 376)
+* org-agenda-bulk-remove-all-marks:      Agenda Commands.     (line 364)
+* org-agenda-bulk-toggle:                Agenda Commands.     (line 368)
+* org-agenda-bulk-toggle-all:            Agenda Commands.     (line 372)
+* org-agenda-bulk-unmark:                Agenda Commands.     (line 360)
+* org-agenda-capture:                    Agenda Commands.     (line 342)
+* org-agenda-clock-cancel:               Agenda Commands.     (line 336)
 * org-agenda-clock-goto:                 Agenda Commands.     (line 124)
-* org-agenda-clock-goto <1>:             Agenda Commands.     (line 342)
-* org-agenda-clock-in:                   Agenda Commands.     (line 332)
-* org-agenda-clock-out:                  Agenda Commands.     (line 336)
+* org-agenda-clock-goto <1>:             Agenda Commands.     (line 339)
+* org-agenda-clock-in:                   Agenda Commands.     (line 329)
+* org-agenda-clock-out:                  Agenda Commands.     (line 333)
 * org-agenda-clockreport-mode:           Agenda Commands.     (line 154)
 * org-agenda-columns:                    Agenda Commands.     (line 197)
 * org-agenda-columns <1>:                Agenda Column View.  (line  12)
-* org-agenda-convert-date:               Agenda Commands.     (line 481)
-* org-agenda-date-prompt:                Agenda Commands.     (line 328)
+* org-agenda-convert-date:               Agenda Commands.     (line 478)
+* org-agenda-date-prompt:                Agenda Commands.     (line 325)
 * org-agenda-day-view:                   Agenda Commands.     (line  71)
-* org-agenda-deadline:                   Agenda Commands.     (line 307)
-* org-agenda-diary-entry:                Agenda Commands.     (line 454)
-* org-agenda-do-date-earlier:            Agenda Commands.     (line 324)
-* org-agenda-do-date-later:              Agenda Commands.     (line 311)
+* org-agenda-deadline:                   Agenda Commands.     (line 304)
+* org-agenda-diary-entry:                Agenda Commands.     (line 451)
+* org-agenda-do-date-earlier:            Agenda Commands.     (line 321)
+* org-agenda-do-date-later:              Agenda Commands.     (line 308)
 * org-agenda-drag-line-backward:         Agenda Commands.     (line 210)
 * org-agenda-drag-line-forward:          Agenda Commands.     (line 217)
 * org-agenda-earlier:                    Agenda Commands.     (line 115)
 * org-agenda-entry-text-mode:            Agenda Commands.     (line 173)
-* org-agenda-exit:                       Agenda Commands.     (line 495)
+* org-agenda-exit:                       Agenda Commands.     (line 492)
 * org-agenda-file-to-front:              Agenda Files.        (line  16)
 * org-agenda-filter:                     Filtering/limiting agenda items.
                                                               (line  73)
@@ -21126,10 +21122,10 @@ F Command and Function Index
                                                               (line  68)
 * org-agenda-follow-mode:                Agenda Commands.     (line  42)
 * org-agenda-goto:                       Agenda Commands.     (line  36)
-* org-agenda-goto-calendar:              Agenda Commands.     (line 447)
+* org-agenda-goto-calendar:              Agenda Commands.     (line 444)
 * org-agenda-goto-date:                  Agenda Commands.     (line 121)
 * org-agenda-goto-today:                 Agenda Commands.     (line 118)
-* org-agenda-holidays:                   Agenda Commands.     (line 485)
+* org-agenda-holidays:                   Agenda Commands.     (line 482)
 * org-agenda-kill:                       Agenda Commands.     (line 243)
 * org-agenda-later:                      Agenda Commands.     (line 110)
 * org-agenda-limit-interactively:        Filtering/limiting agenda items.
@@ -21141,12 +21137,12 @@ F Command and Function Index
 * org-agenda-month-view:                 Agenda Commands.     (line  91)
 * org-agenda-next-line:                  Agenda Commands.     (line  20)
 * org-agenda-open-link:                  Agenda Commands.     (line  56)
-* org-agenda-phases-of-moon:             Agenda Commands.     (line 472)
+* org-agenda-phases-of-moon:             Agenda Commands.     (line 469)
 * org-agenda-previous-line:              Agenda Commands.     (line  23)
 * org-agenda-priority:                   Agenda Commands.     (line 279)
-* org-agenda-priority-down:              Agenda Commands.     (line 292)
-* org-agenda-priority-up:                Agenda Commands.     (line 287)
-* org-agenda-quit:                       Agenda Commands.     (line 491)
+* org-agenda-priority-down:              Agenda Commands.     (line 289)
+* org-agenda-priority-up:                Agenda Commands.     (line 284)
+* org-agenda-quit:                       Agenda Commands.     (line 488)
 * org-agenda-recenter:                   Agenda Commands.     (line  33)
 * org-agenda-redo:                       Agenda Commands.     (line 186)
 * org-agenda-refile:                     Agenda Commands.     (line 249)
@@ -21154,13 +21150,12 @@ F Command and Function Index
 * org-agenda-remove-restriction-lock <1>: Agenda Files.       (line  65)
 * org-agenda-remove-restriction-lock <2>: Agenda Commands.    (line 206)
 * org-agenda-reset-view:                 Agenda Commands.     (line 107)
-* org-agenda-schedule:                   Agenda Commands.     (line 303)
+* org-agenda-schedule:                   Agenda Commands.     (line 300)
 * org-agenda-set-restriction-lock:       Agenda Files.        (line  43)
 * org-agenda-set-tags:                   Agenda Commands.     (line 275)
 * org-agenda-show-and-scroll-up:         Agenda Commands.     (line  29)
-* org-agenda-show-priority:              Agenda Commands.     (line 284)
 * org-agenda-show-tags:                  Agenda Commands.     (line 270)
-* org-agenda-sunrise-sunset:             Agenda Commands.     (line 476)
+* org-agenda-sunrise-sunset:             Agenda Commands.     (line 473)
 * org-agenda-switch-to:                  Agenda Commands.     (line  39)
 * org-agenda-todo:                       Agenda Commands.     (line 231)
 * org-agenda-todo-nextset:               Agenda Commands.     (line 237)
@@ -21185,7 +21180,7 @@ F Command and Function Index
                                                               (line  26)
 * org-attach:                            Attachment defaults and dispatcher.
                                                               (line  19)
-* org-attach <1>:                        Agenda Commands.     (line 300)
+* org-attach <1>:                        Agenda Commands.     (line 297)
 * org-attach-attach:                     Attachment defaults and dispatcher.
                                                               (line  24)
 * org-attach-buffer:                     Attachment defaults and dispatcher.
@@ -21280,7 +21275,7 @@ F Command and Function Index
 * org-beamer-select-environment:         Editing support.     (line  12)
 * org-buffer-property-keys:              Using the Property API.
                                                               (line  34)
-* org-calendar-goto-agenda:              Agenda Commands.     (line 450)
+* org-calendar-goto-agenda:              Agenda Commands.     (line 447)
 * org-capture:                           Activation.          (line  13)
 * org-capture <1>:                       Using capture.       (line   7)
 * org-capture-finalize:                  Using capture.       (line  15)
@@ -21734,9 +21729,9 @@ org-customize’ and then click yourself through the tree.
 * org-adapt-indentation:                 Hard indentation.    (line  16)
 * org-agenda-auto-exclude-function:      Filtering/limiting agenda items.
                                                               (line  98)
-* org-agenda-bulk-custom-functions:      Agenda Commands.     (line 352)
-* org-agenda-bulk-custom-functions <1>:  Agenda Commands.     (line 431)
-* org-agenda-bulk-persistent-marks:      Agenda Commands.     (line 383)
+* org-agenda-bulk-custom-functions:      Agenda Commands.     (line 349)
+* org-agenda-bulk-custom-functions <1>:  Agenda Commands.     (line 428)
+* org-agenda-bulk-persistent-marks:      Agenda Commands.     (line 380)
 * org-agenda-category-filter-preset:     Filtering/limiting agenda items.
                                                               (line   6)
 * org-agenda-category-icon-alist:        Categories.          (line  16)
@@ -21750,7 +21745,7 @@ org-customize’ and then click yourself through the tree.
 * org-agenda-custom-commands <3>:        Extracting Agenda Information.
                                                               (line  10)
 * org-agenda-custom-commands-contexts:   Setting options.     (line  59)
-* org-agenda-diary-file:                 Agenda Commands.     (line 460)
+* org-agenda-diary-file:                 Agenda Commands.     (line 457)
 * org-agenda-dim-blocked-tasks:          TODO dependencies.   (line  48)
 * org-agenda-dim-blocked-tasks <1>:      Speeding Up Your Agendas.
                                                               (line  15)
@@ -21885,7 +21880,7 @@ org-customize’ and then click yourself through the tree.
 * org-capture-templates:                 Capture templates.   (line  11)
 * org-capture-templates-contexts:        Templates in contexts.
                                                               (line   6)
-* org-capture-use-agenda-date:           Agenda Commands.     (line 345)
+* org-capture-use-agenda-date:           Agenda Commands.     (line 342)
 * org-catch-invisible-edits:             Catching invisible edits.
                                                               (line   6)
 * org-clock-continuously:                Clocking commands.   (line   7)
@@ -22216,7 +22211,7 @@ org-customize’ and then click yourself through the tree.
 * org-log-done <2>:                      In-buffer Settings.  (line 101)
 * org-log-into-drawer:                   Tracking TODO state changes.
                                                               (line   6)
-* org-log-into-drawer <1>:               Agenda Commands.     (line 295)
+* org-log-into-drawer <1>:               Agenda Commands.     (line 292)
 * org-log-note-clock-out:                Clocking commands.   (line  36)
 * org-log-note-clock-out <1>:            In-buffer Settings.  (line 101)
 * org-log-redeadline:                    Inserting deadline/schedule.
@@ -22701,307 +22696,307 @@ Ref: Motion (1)359304
 Ref: View/Go to Org file359507
 Ref: Change display361013
 Ref: Remote editing368523
-Ref: Bulk remote editing selected entries373851
-Ref: Calendar commands376946
-Ref: Quit and exit378827
-Ref: Agenda Commands-Footnote-1379189
-Ref: Agenda Commands-Footnote-2379265
-Ref: Agenda Commands-Footnote-3379369
-Node: Custom Agenda Views379456
-Node: Storing searches380103
-Ref: Storing searches-Footnote-1383050
-Ref: Storing searches-Footnote-2383167
-Node: Block agenda383414
-Node: Setting options384665
-Node: Exporting Agenda Views388274
-Ref: Exporting Agenda Views-Footnote-1392808
-Ref: Exporting Agenda Views-Footnote-2392996
-Ref: Exporting Agenda Views-Footnote-3393146
-Ref: Exporting Agenda Views-Footnote-4393333
-Node: Agenda Column View393415
-Node: Markup for Rich Contents396758
-Node: Paragraphs398051
-Node: Emphasis and Monospace399181
-Node: Subscripts and Superscripts399827
-Node: Special Symbols400879
-Ref: Special Symbols-Footnote-1402787
-Ref: Special Symbols-Footnote-2402952
-Node: Embedded LaTeX403049
-Ref: Embedded LaTeX-Footnote-1403893
-Node: LaTeX fragments404089
-Ref: LaTeX fragments-Footnote-1406240
-Node: Previewing LaTeX fragments406433
-Ref: Previewing LaTeX fragments-Footnote-1407911
-Node: CDLaTeX mode408159
-Ref: CDLaTeX mode-Footnote-1410884
-Node: Literal Examples411031
-Ref: Literal Examples-Footnote-1416137
-Ref: Literal Examples-Footnote-2416507
-Ref: Literal Examples-Footnote-3416685
-Ref: Literal Examples-Footnote-4416870
-Node: Images416968
-Ref: Images-Footnote-1418050
-Ref: Images-Footnote-2418173
-Node: Captions418334
-Node: Horizontal Rules419029
-Node: Creating Footnotes419280
-Ref: Creating Footnotes-Footnote-1422404
-Ref: Creating Footnotes-Footnote-2422510
-Node: Exporting422617
-Node: The Export Dispatcher425382
-Node: Export Settings428095
-Ref: Export Settings-Footnote-1436189
-Ref: Export Settings-Footnote-2436301
-Ref: Export Settings-Footnote-3436402
-Node: Table of Contents436600
-Ref: Table of Contents-Footnote-1439269
-Node: Include Files439436
-Ref: Include Files-Footnote-1442368
-Node: Macro Replacement442546
-Ref: Macro Replacement-Footnote-1446421
-Node: Comment Lines446638
-Ref: Comment Lines-Footnote-1447496
-Node: ASCII/Latin-1/UTF-8 export447600
-Ref: ASCII export commands448449
-Ref: ASCII specific export settings448982
-Ref: Header and sectioning structure449426
-Ref: Quoting ASCII text449700
-Ref: ASCII specific attributes450072
-Ref: ASCII special blocks450349
-Node: Beamer Export450696
-Node: Beamer export commands451441
-Node: Beamer specific export settings452141
-Node: Frames and Blocks in Beamer454041
-Ref: Frames and Blocks in Beamer-Footnote-1457408
-Node: Beamer specific syntax457567
-Node: Editing support459541
-Node: A Beamer example460007
-Node: HTML Export461256
-Node: HTML export commands462361
-Node: HTML specific export settings462907
-Node: HTML doctypes464996
-Node: HTML preamble and postamble467172
-Node: Quoting HTML tags468362
-Node: Headlines in HTML export469056
-Node: Links in HTML export469646
-Node: Tables in HTML export471111
-Node: Images in HTML export472566
-Node: Math formatting in HTML export474051
-Ref: Math formatting in HTML export-Footnote-1475586
-Ref: Math formatting in HTML export-Footnote-2475710
-Ref: Math formatting in HTML export-Footnote-3475971
-Node: Text areas in HTML export476143
-Node: CSS support477283
-Ref: CSS support-Footnote-1480930
-Node: JavaScript support481110
-Node: LaTeX Export484363
-Node: LaTeX/PDF export commands486136
-Ref: LaTeX/PDF export commands-Footnote-1487634
-Node: LaTeX specific export settings487836
-Node: LaTeX header and sectioning491063
-Node: Quoting LaTeX code493175
-Node: Tables in LaTeX export493966
-Node: Images in LaTeX export498379
-Node: Plain lists in LaTeX export500977
-Node: Source blocks in LaTeX export501992
-Node: Example blocks in LaTeX export503417
-Node: Special blocks in LaTeX export504138
-Node: Horizontal rules in LaTeX export505396
-Node: Markdown Export505791
-Ref: Markdown export commands506253
-Ref: Header and sectioning structure (1)506690
-Node: OpenDocument Text Export507107
-Ref: OpenDocument Text Export-Footnote-1508208
-Node: Pre-requisites for ODT export508357
-Node: ODT export commands508730
-Node: ODT specific export settings509906
-Node: Extending ODT export510952
-Ref: Automatically exporting to other formats511758
-Ref: Converting between document formats512184
-Node: Applying custom styles512726
-Ref: Applying custom styles the easy way513253
-Ref: Using third-party styles and templates514211
-Node: Links in ODT export514508
-Node: Tables in ODT export515165
-Node: Images in ODT export517170
-Ref: Embedding images517369
-Ref: Embedding clickable images517686
-Ref: Sizing and scaling of embedded images518020
-Ref: Anchoring of images519704
-Node: Math formatting in ODT export520026
-Node: LaTeX math snippets520450
-Ref: LaTeX math snippets-Footnote-1522698
-Ref: LaTeX math snippets-Footnote-2522774
-Node: MathML and OpenDocument formula files522819
-Node: Labels and captions in ODT export523322
-Node: Literal examples in ODT export524593
-Node: Advanced topics in ODT export525429
-Ref: Configuring a document converter525734
-Ref: Working with OpenDocument style files526675
-Ref: x-orgodtstyles-xml527141
-Ref: x-orgodtcontenttemplate-xml527483
-Ref: x-overriding-factory-styles528127
-Ref: Creating one-off styles529371
-Ref: Customizing tables in ODT export531375
-Ref: Validating OpenDocument XML536235
-Ref: Advanced topics in ODT export-Footnote-1537032
-Ref: Advanced topics in ODT export-Footnote-2537136
-Ref: Advanced topics in ODT export-Footnote-3537229
-Node: Org Export537577
-Ref: Org export commands537928
-Node: Texinfo Export538234
-Node: Texinfo export commands539212
-Node: Texinfo specific export settings539832
-Node: Texinfo file header540980
-Node: Texinfo title and copyright page541958
-Node: Info directory file543317
-Node: Headings and sectioning structure544037
-Node: Indices546062
-Node: Quoting Texinfo code547086
-Node: Plain lists in Texinfo export547579
-Node: Tables in Texinfo export549300
-Node: Images in Texinfo export549791
-Node: Quotations in Texinfo export550424
-Node: Special blocks in Texinfo export551372
-Node: A Texinfo example552020
-Node: iCalendar Export554117
-Node: Other Built-in Back-ends558401
-Node: Advanced Export Configuration559028
-Ref: Hooks559235
-Ref: Filters560158
-Ref: Defining filters for individual files562667
-Ref: Extending an existing back-end563473
-Node: Export in Foreign Buffers565713
-Node: Publishing566861
-Node: Configuration567739
-Node: Project alist568516
-Node: Sources and destinations569653
-Node: Selecting files570966
-Node: Publishing action571916
-Ref: Publishing action-Footnote-1573740
-Node: Publishing options573903
-Ref: Generic properties574650
-Ref: ASCII specific properties576537
-Ref: Beamer specific properties578137
-Ref: HTML specific properties578702
-Ref: LaTeX specific properties583094
-Ref: Markdown specific properties586018
-Ref: ODT specific properties586256
-Ref: Texinfo specific properties587188
-Node: Publishing links588535
-Node: Site map589910
-Node: Generating an index593222
-Node: Uploading Files594009
-Node: Sample Configuration595787
-Node: Simple example596280
-Node: Complex example596928
-Node: Triggering Publication598972
-Node: Working with Source Code599993
-Node: Structure of Code Blocks604848
-Node: Using Header Arguments607327
-Ref: System-wide header arguments608049
-Ref: Header arguments in Org mode properties608972
-Ref: Code block specific header arguments610800
-Ref: Header arguments in function calls612299
-Node: Environment of a Code Block612973
-Ref: Passing arguments613182
-Ref: Using sessions621052
-Ref: Choosing a working directory622451
-Ref: Inserting headers and footers624305
-Node: Evaluating Code Blocks624815
-Ref: How to evaluate source code625265
-Ref: Limit code block evaluation628167
-Ref: Cache results of evaluation629027
-Ref: Evaluating Code Blocks-Footnote-1631613
-Ref: Evaluating Code Blocks-Footnote-2631747
-Node: Results of Evaluation631905
-Ref: Collection632707
-Ref: Type634967
-Ref: Format638260
-Ref: Handling640509
-Ref: Post-processing641224
-Node: Exporting Code Blocks642938
-Node: Extracting Source Code645286
-Ref: Header arguments646262
-Ref: Functions649803
-Ref: Hooks (1)650054
-Ref: Jumping between code and Org650289
-Node: Languages650799
-Ref: Languages-Footnote-1653518
-Ref: Languages-Footnote-2653676
-Node: Editing Source Code653830
-Node: Noweb Reference Syntax656553
-Ref: Noweb Reference Syntax-Footnote-1662060
-Node: Library of Babel662150
-Node: Key bindings and Useful Functions662863
-Node: Batch Execution665283
-Node: Miscellaneous666061
-Node: Completion667234
-Node: Structure Templates669151
-Ref: Structure Templates-Footnote-1670896
-Node: Speed Keys670988
-Node: Clean View672160
-Node: Org Indent Mode673346
-Ref: Org Indent Mode-Footnote-1674547
-Node: Hard indentation674771
-Ref: Hard indentation-Footnote-1676246
-Node: Dynamic Headline Numbering676352
-Node: The Very Busy C-c C-c Key677313
-Node: In-buffer Settings679222
-Ref: In-buffer Settings-Footnote-1687920
-Node: Org Syntax688118
-Node: Documentation Access689768
-Node: Escape Character690182
-Node: Code Evaluation Security691038
-Node: Interaction693900
-Node: Cooperation694318
-Node: Conflicts697205
-Node: TTY Keys701802
-Node: Protocols703399
-Node: The store-link protocol704853
-Node: The capture protocol705696
-Node: The open-source protocol706855
-Node: Org Crypt710087
-Node: Org Mobile711619
-Node: Setting up the staging area712938
-Ref: Setting up the staging area-Footnote-1714173
-Ref: Setting up the staging area-Footnote-2714380
-Node: Pushing to the mobile application714552
-Ref: Pushing to the mobile application-Footnote-1715558
-Ref: Pushing to the mobile application-Footnote-2715649
-Ref: Pushing to the mobile application-Footnote-3716016
-Node: Pulling from the mobile application716092
-Ref: Pulling from the mobile application-Footnote-1718400
-Node: Hacking718453
-Node: Hooks (2)719399
-Node: Add-on Packages719722
-Node: Adding Hyperlink Types720260
-Node: Adding Export Back-ends723672
-Node: Tables in Arbitrary Syntax724924
-Node: Radio tables726188
-Node: A LaTeX example728320
-Ref: A LaTeX example-Footnote-1732167
-Ref: A LaTeX example-Footnote-2732210
-Ref: A LaTeX example-Footnote-3732371
-Node: Translator functions732823
-Node: Dynamic Blocks734994
-Node: Special Agenda Views737235
-Ref: Special Agenda Views-Footnote-1740941
-Ref: Special Agenda Views-Footnote-2741148
-Node: Speeding Up Your Agendas741280
-Node: Extracting Agenda Information742334
-Node: Using the Property API746134
-Node: Using the Mapping API749484
-Node: History and Acknowledgments753515
-Ref: From Carsten753708
-Ref: From Bastien757139
-Ref: List of Contributions759271
-Node: GNU Free Documentation License767474
-Ref: ADDENDUM How to use this License for your documents791425
-Node: Main Index792818
-Node: Key Index889200
-Node: Command and Function Index945002
-Node: Variable Index991266
+Ref: Bulk remote editing selected entries373761
+Ref: Calendar commands376856
+Ref: Quit and exit378737
+Ref: Agenda Commands-Footnote-1379099
+Ref: Agenda Commands-Footnote-2379175
+Ref: Agenda Commands-Footnote-3379279
+Node: Custom Agenda Views379366
+Node: Storing searches380013
+Ref: Storing searches-Footnote-1382960
+Ref: Storing searches-Footnote-2383077
+Node: Block agenda383324
+Node: Setting options384575
+Node: Exporting Agenda Views388184
+Ref: Exporting Agenda Views-Footnote-1392718
+Ref: Exporting Agenda Views-Footnote-2392906
+Ref: Exporting Agenda Views-Footnote-3393056
+Ref: Exporting Agenda Views-Footnote-4393243
+Node: Agenda Column View393325
+Node: Markup for Rich Contents396668
+Node: Paragraphs397961
+Node: Emphasis and Monospace399091
+Node: Subscripts and Superscripts399737
+Node: Special Symbols400789
+Ref: Special Symbols-Footnote-1402697
+Ref: Special Symbols-Footnote-2402862
+Node: Embedded LaTeX402959
+Ref: Embedded LaTeX-Footnote-1403803
+Node: LaTeX fragments403999
+Ref: LaTeX fragments-Footnote-1406150
+Node: Previewing LaTeX fragments406343
+Ref: Previewing LaTeX fragments-Footnote-1407821
+Node: CDLaTeX mode408069
+Ref: CDLaTeX mode-Footnote-1410794
+Node: Literal Examples410941
+Ref: Literal Examples-Footnote-1416047
+Ref: Literal Examples-Footnote-2416417
+Ref: Literal Examples-Footnote-3416595
+Ref: Literal Examples-Footnote-4416780
+Node: Images416878
+Ref: Images-Footnote-1417960
+Ref: Images-Footnote-2418083
+Node: Captions418244
+Node: Horizontal Rules418939
+Node: Creating Footnotes419190
+Ref: Creating Footnotes-Footnote-1422314
+Ref: Creating Footnotes-Footnote-2422420
+Node: Exporting422527
+Node: The Export Dispatcher425292
+Node: Export Settings428005
+Ref: Export Settings-Footnote-1436099
+Ref: Export Settings-Footnote-2436211
+Ref: Export Settings-Footnote-3436312
+Node: Table of Contents436510
+Ref: Table of Contents-Footnote-1439179
+Node: Include Files439346
+Ref: Include Files-Footnote-1442278
+Node: Macro Replacement442456
+Ref: Macro Replacement-Footnote-1446331
+Node: Comment Lines446548
+Ref: Comment Lines-Footnote-1447406
+Node: ASCII/Latin-1/UTF-8 export447510
+Ref: ASCII export commands448359
+Ref: ASCII specific export settings448892
+Ref: Header and sectioning structure449336
+Ref: Quoting ASCII text449610
+Ref: ASCII specific attributes449982
+Ref: ASCII special blocks450259
+Node: Beamer Export450606
+Node: Beamer export commands451351
+Node: Beamer specific export settings452051
+Node: Frames and Blocks in Beamer453951
+Ref: Frames and Blocks in Beamer-Footnote-1457318
+Node: Beamer specific syntax457477
+Node: Editing support459451
+Node: A Beamer example459917
+Node: HTML Export461166
+Node: HTML export commands462271
+Node: HTML specific export settings462817
+Node: HTML doctypes464906
+Node: HTML preamble and postamble467082
+Node: Quoting HTML tags468272
+Node: Headlines in HTML export468966
+Node: Links in HTML export469556
+Node: Tables in HTML export471021
+Node: Images in HTML export472476
+Node: Math formatting in HTML export473961
+Ref: Math formatting in HTML export-Footnote-1475496
+Ref: Math formatting in HTML export-Footnote-2475620
+Ref: Math formatting in HTML export-Footnote-3475881
+Node: Text areas in HTML export476053
+Node: CSS support477193
+Ref: CSS support-Footnote-1480840
+Node: JavaScript support481020
+Node: LaTeX Export484273
+Node: LaTeX/PDF export commands486046
+Ref: LaTeX/PDF export commands-Footnote-1487544
+Node: LaTeX specific export settings487746
+Node: LaTeX header and sectioning490973
+Node: Quoting LaTeX code493085
+Node: Tables in LaTeX export493876
+Node: Images in LaTeX export498289
+Node: Plain lists in LaTeX export500887
+Node: Source blocks in LaTeX export501902
+Node: Example blocks in LaTeX export503327
+Node: Special blocks in LaTeX export504048
+Node: Horizontal rules in LaTeX export505306
+Node: Markdown Export505701
+Ref: Markdown export commands506163
+Ref: Header and sectioning structure (1)506600
+Node: OpenDocument Text Export507017
+Ref: OpenDocument Text Export-Footnote-1508118
+Node: Pre-requisites for ODT export508267
+Node: ODT export commands508640
+Node: ODT specific export settings509816
+Node: Extending ODT export510862
+Ref: Automatically exporting to other formats511668
+Ref: Converting between document formats512094
+Node: Applying custom styles512636
+Ref: Applying custom styles the easy way513163
+Ref: Using third-party styles and templates514121
+Node: Links in ODT export514418
+Node: Tables in ODT export515075
+Node: Images in ODT export517080
+Ref: Embedding images517279
+Ref: Embedding clickable images517596
+Ref: Sizing and scaling of embedded images517930
+Ref: Anchoring of images519614
+Node: Math formatting in ODT export519936
+Node: LaTeX math snippets520360
+Ref: LaTeX math snippets-Footnote-1522608
+Ref: LaTeX math snippets-Footnote-2522684
+Node: MathML and OpenDocument formula files522729
+Node: Labels and captions in ODT export523232
+Node: Literal examples in ODT export524503
+Node: Advanced topics in ODT export525339
+Ref: Configuring a document converter525644
+Ref: Working with OpenDocument style files526585
+Ref: x-orgodtstyles-xml527051
+Ref: x-orgodtcontenttemplate-xml527393
+Ref: x-overriding-factory-styles528037
+Ref: Creating one-off styles529281
+Ref: Customizing tables in ODT export531285
+Ref: Validating OpenDocument XML536145
+Ref: Advanced topics in ODT export-Footnote-1536942
+Ref: Advanced topics in ODT export-Footnote-2537046
+Ref: Advanced topics in ODT export-Footnote-3537139
+Node: Org Export537487
+Ref: Org export commands537838
+Node: Texinfo Export538144
+Node: Texinfo export commands539122
+Node: Texinfo specific export settings539742
+Node: Texinfo file header540890
+Node: Texinfo title and copyright page541868
+Node: Info directory file543227
+Node: Headings and sectioning structure543947
+Node: Indices545972
+Node: Quoting Texinfo code546996
+Node: Plain lists in Texinfo export547489
+Node: Tables in Texinfo export549210
+Node: Images in Texinfo export549701
+Node: Quotations in Texinfo export550334
+Node: Special blocks in Texinfo export551282
+Node: A Texinfo example551930
+Node: iCalendar Export554027
+Node: Other Built-in Back-ends558311
+Node: Advanced Export Configuration558938
+Ref: Hooks559145
+Ref: Filters560068
+Ref: Defining filters for individual files562577
+Ref: Extending an existing back-end563383
+Node: Export in Foreign Buffers565623
+Node: Publishing566771
+Node: Configuration567649
+Node: Project alist568426
+Node: Sources and destinations569563
+Node: Selecting files570876
+Node: Publishing action571826
+Ref: Publishing action-Footnote-1573650
+Node: Publishing options573813
+Ref: Generic properties574560
+Ref: ASCII specific properties576447
+Ref: Beamer specific properties578047
+Ref: HTML specific properties578612
+Ref: LaTeX specific properties583004
+Ref: Markdown specific properties585928
+Ref: ODT specific properties586166
+Ref: Texinfo specific properties587098
+Node: Publishing links588445
+Node: Site map589820
+Node: Generating an index593132
+Node: Uploading Files593919
+Node: Sample Configuration595697
+Node: Simple example596190
+Node: Complex example596838
+Node: Triggering Publication598882
+Node: Working with Source Code599903
+Node: Structure of Code Blocks604758
+Node: Using Header Arguments607237
+Ref: System-wide header arguments607959
+Ref: Header arguments in Org mode properties608882
+Ref: Code block specific header arguments610710
+Ref: Header arguments in function calls612209
+Node: Environment of a Code Block612883
+Ref: Passing arguments613092
+Ref: Using sessions620962
+Ref: Choosing a working directory622361
+Ref: Inserting headers and footers624215
+Node: Evaluating Code Blocks624725
+Ref: How to evaluate source code625175
+Ref: Limit code block evaluation628077
+Ref: Cache results of evaluation628937
+Ref: Evaluating Code Blocks-Footnote-1631523
+Ref: Evaluating Code Blocks-Footnote-2631657
+Node: Results of Evaluation631815
+Ref: Collection632617
+Ref: Type634877
+Ref: Format638170
+Ref: Handling640419
+Ref: Post-processing641134
+Node: Exporting Code Blocks642848
+Node: Extracting Source Code645196
+Ref: Header arguments646172
+Ref: Functions649713
+Ref: Hooks (1)649964
+Ref: Jumping between code and Org650199
+Node: Languages650709
+Ref: Languages-Footnote-1653428
+Ref: Languages-Footnote-2653586
+Node: Editing Source Code653740
+Node: Noweb Reference Syntax656463
+Ref: Noweb Reference Syntax-Footnote-1661970
+Node: Library of Babel662060
+Node: Key bindings and Useful Functions662773
+Node: Batch Execution665193
+Node: Miscellaneous665971
+Node: Completion667144
+Node: Structure Templates669061
+Ref: Structure Templates-Footnote-1670806
+Node: Speed Keys670898
+Node: Clean View672070
+Node: Org Indent Mode673256
+Ref: Org Indent Mode-Footnote-1674457
+Node: Hard indentation674681
+Ref: Hard indentation-Footnote-1676156
+Node: Dynamic Headline Numbering676262
+Node: The Very Busy C-c C-c Key677223
+Node: In-buffer Settings679132
+Ref: In-buffer Settings-Footnote-1687830
+Node: Org Syntax688028
+Node: Documentation Access689678
+Node: Escape Character690092
+Node: Code Evaluation Security690948
+Node: Interaction693810
+Node: Cooperation694228
+Node: Conflicts697115
+Node: TTY Keys701712
+Node: Protocols703309
+Node: The store-link protocol704763
+Node: The capture protocol705606
+Node: The open-source protocol706765
+Node: Org Crypt709997
+Node: Org Mobile711529
+Node: Setting up the staging area712848
+Ref: Setting up the staging area-Footnote-1714083
+Ref: Setting up the staging area-Footnote-2714290
+Node: Pushing to the mobile application714462
+Ref: Pushing to the mobile application-Footnote-1715468
+Ref: Pushing to the mobile application-Footnote-2715559
+Ref: Pushing to the mobile application-Footnote-3715926
+Node: Pulling from the mobile application716002
+Ref: Pulling from the mobile application-Footnote-1718310
+Node: Hacking718363
+Node: Hooks (2)719309
+Node: Add-on Packages719632
+Node: Adding Hyperlink Types720170
+Node: Adding Export Back-ends723582
+Node: Tables in Arbitrary Syntax724834
+Node: Radio tables726098
+Node: A LaTeX example728230
+Ref: A LaTeX example-Footnote-1732077
+Ref: A LaTeX example-Footnote-2732120
+Ref: A LaTeX example-Footnote-3732281
+Node: Translator functions732733
+Node: Dynamic Blocks734904
+Node: Special Agenda Views737145
+Ref: Special Agenda Views-Footnote-1740851
+Ref: Special Agenda Views-Footnote-2741058
+Node: Speeding Up Your Agendas741190
+Node: Extracting Agenda Information742244
+Node: Using the Property API746044
+Node: Using the Mapping API749394
+Node: History and Acknowledgments753425
+Ref: From Carsten753618
+Ref: From Bastien757049
+Ref: List of Contributions759181
+Node: GNU Free Documentation License767384
+Ref: ADDENDUM How to use this License for your documents791335
+Node: Main Index792728
+Node: Key Index889110
+Node: Command and Function Index944839
+Node: Variable Index991030
 
 End Tag Table
 
diff --git a/elpa/org-9.3.2/org-agenda.el b/elpa/org-9.3.3/org-agenda.el
similarity index 99%
rename from elpa/org-9.3.2/org-agenda.el
rename to elpa/org-9.3.3/org-agenda.el
index 43e5495f..692703c6 100644
--- a/elpa/org-9.3.2/org-agenda.el
+++ b/elpa/org-9.3.3/org-agenda.el
@@ -1156,6 +1156,11 @@ argument, a calendar-style date list like (month day year)."
 	  (string :tag "Format string")
 	  (function :tag "Function")))
 
+(defun org-agenda-end-of-line ()
+  "Go to the end of visible line."
+  (interactive)
+  (goto-char (line-end-position)))
+
 (defun org-agenda-format-date-aligned (date)
   "Format a DATE string for display in the daily/weekly agenda.
 This function makes sure that dates are aligned for easy reading."
@@ -2101,6 +2106,8 @@ evaluate to a string."
 (defvar org-agenda-mode-map (make-sparse-keymap)
   "Keymap for `org-agenda-mode'.")
 
+(org-remap org-agenda-mode-map 'move-end-of-line 'org-agenda-end-of-line)
+
 (defvar org-agenda-menu) ; defined later in this file.
 (defvar org-agenda-restrict nil) ; defined later in this file.
 (defvar org-agenda-follow-mode nil)
@@ -2197,8 +2204,10 @@ The following commands are available:
 
 \\{org-agenda-mode-map}"
   (interactive)
+  (ignore-errors (require 'face-remap))
   (let ((agenda-local-vars-to-keep
 	 '(text-scale-mode-amount
+	   text-scale-mode
 	   text-scale-mode-lighter
 	   face-remapping-alist))
 	(save (buffer-local-variables)))
@@ -4364,7 +4373,7 @@ items if they have an hour specification like [h]h:mm."
 	  (insert tbl)))
       (goto-char (point-min))
       (or org-agenda-multi (org-agenda-fit-window-to-buffer))
-      (unless (or (not (get-buffer-window))
+      (unless (or (not (get-buffer-window org-agenda-buffer-name))
 		  (and (pos-visible-in-window-p (point-min))
 		       (pos-visible-in-window-p (point-max))))
 	(goto-char (1- (point-max)))
@@ -6273,6 +6282,10 @@ scheduled items with an hour specification like [h]h:mm."
 			    (org-agenda--timestamp-to-absolute deadline))
 			 org-scheduled-delay-days))
 		   (t 0))))
+	       (diff-r (abs (- repeat current)))
+	       (ddays-once (or (and (string-match "--\\([0-9]+\\)[hdwmy]" s)
+				    (string-to-number (match-string 1 s)))
+			       0))
 	       (ddays
 		(cond
 		 ;; Nullify delay when a repeater triggered already
@@ -6291,13 +6304,25 @@ scheduled items with an hour specification like [h]h:mm."
 	  (unless (and todayp
 		       habitp
 		       (bound-and-true-p org-habit-show-all-today))
-	    (when (or (and (> ddays 0) (< diff ddays))
-		      (> diff (or (and habitp org-habit-scheduled-past-days)
-				  org-scheduled-past-days))
-		      (> schedule current)
-		      (and (/= current schedule)
-			   (/= current today)
-			   (/= current repeat)))
+	    (when (or
+		   ;; no one-time delay, not repeated delay
+		   (and (not ddays-once) (not (= ddays diff-r)))
+		   ;; one-time delay, but not for today
+		   (and ddays-once
+			(not (= diff diff-r))
+			(= ddays-once diff-r))
+		   ;; normal delay, but already in the past
+		   (and (> ddays 0) (< diff ddays))
+		   ;; a habit, but past `org-habit-scheduled-past-days'
+		   (> diff (or (and habitp org-habit-scheduled-past-days)
+			       org-scheduled-past-days))
+		   ;; schedule in the future
+		   (> schedule current)
+		   ;; no delay, not scheduled today, no deadline for today
+		   (and (= ddays 0)
+			(/= current schedule)
+			(/= current today)
+			(/= current repeat)))
 	      (throw :skip nil)))
 	  ;; Possibly skip done tasks.
 	  (when (and donep
@@ -6457,7 +6482,6 @@ scheduled items with an hour specification like [h]h:mm."
 			  (and (eq org-agenda-show-inherited-tags t)
 			       (or (eq org-agenda-use-tag-inheritance t)
 				   (memq 'agenda org-agenda-use-tag-inheritance))))
-
 		      tags (org-get-tags nil (not inherited-tags)))
 		(setq level (make-string (org-reduced-level (org-outline-level)) ? ))
 		(looking-at "\\*+[ \t]+\\(.*\\)")
@@ -6475,12 +6499,19 @@ scheduled items with an hour specification like [h]h:mm."
 				   org-agenda-timerange-leaders)
 			      (1+ (- d0 d1)) (1+ (- d2 d1)))
 			     head level category tags
-			     (cond ((and (= d1 d0) (= d2 d0))
-				    (concat "<" start-time ">--<" end-time ">"))
-                                   ((= d1 d0)
-				    (concat "<" start-time ">"))
-				   ((= d2 d0)
-				    (concat "<" end-time ">")))
+			     (save-match-data
+			       (let ((hhmm1 (and (string-match org-ts-regexp1 s1)
+						 (match-string 6 s1)))
+				     (hhmm2 (and (string-match org-ts-regexp1 s2)
+						 (match-string 6 s2))))
+				 (cond ((string= hhmm1 hhmm2)
+					(concat "<" start-time ">--<" end-time ">"))
+				       ((and (= d1 d0) (= d2 d0))
+					(concat "<" start-time ">--<" end-time ">"))
+                                       ((= d1 d0)
+					(concat "<" start-time ">"))
+				       ((= d2 d0)
+					(concat "<" end-time ">")))))
 			     remove-re))))
 	      (org-add-props txt props
 		'org-marker marker 'org-hd-marker hdmarker
@@ -7709,11 +7740,10 @@ the variable `org-agenda-auto-exclude-function'."
       (and fe (org-agenda-filter-apply
 	       (setq org-agenda-effort-filter fe) 'effort))
       (and fr (org-agenda-filter-apply
-	       (setq org-agenda-regexp-filter fr) 'regexp))
-      )))
+	       (setq org-agenda-regexp-filter fr) 'regexp)))))
 
 (defun org-agenda-filter-completion-function (string _predicate &optional flag)
-  "Complete a complex filter string
+  "Complete a complex filter string.
 FLAG specifies the type of completion operation to perform.  This
 function is passed as a collection function to `completing-read',
 which see."
@@ -8035,7 +8065,8 @@ tags in the FILTER if any of the tags in FILTER are grouptags."
 
 (defun org-agenda-filter-hide-line (type)
   "Hide lines with TYPE in the agenda buffer."
-  (let* ((b (max (point-min) (1- (point-at-bol))))
+  (let* (buffer-invisibility-spec
+	 (b (max (point-min) (1- (point-at-bol))))
 	 (e (point-at-eol)))
     (let ((inhibit-read-only t))
       (add-text-properties
@@ -8893,11 +8924,14 @@ It also looks at the text of the entry itself."
 		  (setq trg (and (string-match org-link-bracket-re l)
 				 (match-string 1 l)))
 		  (if (or (not trg) (string-match org-link-any-re trg))
-		      (org-with-wide-buffer
-		       (goto-char marker)
-		       (when (search-forward l nil lkend)
-			 (goto-char (match-beginning 0))
-			 (org-open-at-point)))
+		      ;; Don't use `org-with-wide-buffer' here as
+		      ;; opening the link may result in moving the point
+		      (save-restriction
+			(widen)
+			(goto-char marker)
+			(when (search-forward l nil lkend)
+			  (goto-char (match-beginning 0))
+			  (org-open-at-point)))
 		    ;; This is an internal link, widen the buffer
 		    (switch-to-buffer-other-window buffer)
 		    (widen)
@@ -8981,7 +9015,6 @@ fold drawers."
 	 (narrow-to-region (org-entry-beginning-position)
 			   (org-entry-end-position))
 	 (org-show-all '(drawers))))
-      (when arg )
       (setq org-agenda-show-window (selected-window)))
     (select-window win)))
 
@@ -9541,14 +9574,17 @@ Called with a universal prefix arg, show the priority instead of setting it."
       (goto-char (point-max))
       (while (not (bobp))
 	(when (equal marker (org-get-at-bol 'org-marker))
-          (remove-text-properties (point-at-bol) (point-at-eol) '(display nil))
-	  (org-move-to-column (- (window-width) (length stamp)) t)
+          (remove-text-properties (line-beginning-position)
+				  (line-end-position)
+				  '(display nil))
+	  (org-move-to-column
+	   (- (/ (window-width nil t) (window-font-width)) (length stamp)) t)
           (add-text-properties
 	   (1- (point)) (point-at-eol)
 	   (list 'display (org-add-props stamp nil
 			    'face '(secondary-selection default))))
 	  (beginning-of-line 1))
-	(beginning-of-line 0)))))
+	(org-agenda-previous-line)))))
 
 (defun org-agenda-date-prompt (arg)
   "Change the date of this item.  Date is prompted for, with default today.
diff --git a/elpa/org-9.3.2/org-agenda.elc b/elpa/org-9.3.3/org-agenda.elc
similarity index 92%
rename from elpa/org-9.3.2/org-agenda.elc
rename to elpa/org-9.3.3/org-agenda.elc
index 60cbd073..03d46685 100644
Binary files a/elpa/org-9.3.2/org-agenda.elc and b/elpa/org-9.3.3/org-agenda.elc differ
diff --git a/elpa/org-9.3.2/org-archive.el b/elpa/org-9.3.3/org-archive.el
similarity index 100%
rename from elpa/org-9.3.2/org-archive.el
rename to elpa/org-9.3.3/org-archive.el
diff --git a/elpa/org-9.3.2/org-archive.elc b/elpa/org-9.3.3/org-archive.elc
similarity index 100%
rename from elpa/org-9.3.2/org-archive.elc
rename to elpa/org-9.3.3/org-archive.elc
diff --git a/elpa/org-9.3.2/org-attach-git.el b/elpa/org-9.3.3/org-attach-git.el
similarity index 100%
rename from elpa/org-9.3.2/org-attach-git.el
rename to elpa/org-9.3.3/org-attach-git.el
diff --git a/elpa/org-9.3.2/org-attach-git.elc b/elpa/org-9.3.3/org-attach-git.elc
similarity index 100%
rename from elpa/org-9.3.2/org-attach-git.elc
rename to elpa/org-9.3.3/org-attach-git.elc
diff --git a/elpa/org-9.3.2/org-attach.el b/elpa/org-9.3.3/org-attach.el
similarity index 99%
rename from elpa/org-9.3.2/org-attach.el
rename to elpa/org-9.3.3/org-attach.el
index 6148657b..62acc229 100644
--- a/elpa/org-9.3.2/org-attach.el
+++ b/elpa/org-9.3.3/org-attach.el
@@ -4,7 +4,6 @@
 
 ;; Author: John Wiegley <johnw@newartisans.com>
 ;; Keywords: org data attachment
-
 ;; This file is part of GNU Emacs.
 ;;
 ;; GNU Emacs is free software: you can redistribute it and/or modify
@@ -491,7 +490,7 @@ METHOD may be `cp', `mv', `ln', `lns' or `url' default taken from
 `org-attach-method'."
   (interactive
    (list
-    (read-file-name "File to keep as an attachment:"
+    (read-file-name "File to keep as an attachment: "
                     (or (progn
                           (require 'dired-aux)
                           (dired-dwim-target-directory))
@@ -516,7 +515,7 @@ METHOD may be `cp', `mv', `ln', `lns' or `url' default taken from
              (org-attach-store-link file)))
       (if visit-dir
           (dired attach-dir)
-        (message "File %S is now an attachment." basename)))))
+        (message "File %S is now an attachment" basename)))))
 
 (defun org-attach-attach-cp ()
   "Attach a file by copying it."
diff --git a/elpa/org-9.3.2/org-attach.elc b/elpa/org-9.3.3/org-attach.elc
similarity index 99%
rename from elpa/org-9.3.2/org-attach.elc
rename to elpa/org-9.3.3/org-attach.elc
index eef1d642..3919548b 100644
Binary files a/elpa/org-9.3.2/org-attach.elc and b/elpa/org-9.3.3/org-attach.elc differ
diff --git a/elpa/org-9.3.2/org-autoloads.el b/elpa/org-9.3.3/org-autoloads.el
similarity index 98%
rename from elpa/org-9.3.2/org-autoloads.el
rename to elpa/org-9.3.3/org-autoloads.el
index a5291f90..30ea3f93 100644
--- a/elpa/org-9.3.2/org-autoloads.el
+++ b/elpa/org-9.3.3/org-autoloads.el
@@ -229,6 +229,14 @@
 
 (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "ob-lisp" '("org-babel-")))
 
+;;;***
+
+;;;### (autoloads "actual autoloads are elsewhere" "ob-lob" "ob-lob.el"
+;;;;;;  (0 0 0 0))
+;;; Generated autoloads from ob-lob.el
+
+(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "ob-lob" '("org-babel-")))
+
 ;;;***
 
 ;;;### (autoloads nil "ob-lua" "ob-lua.el" (0 0 0 0))
@@ -1674,6 +1682,14 @@ Inserted by installing Org or when a release is made.
 
 (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "ox-man" '("org-man-")))
 
+;;;***
+
+;;;### (autoloads "actual autoloads are elsewhere" "ox-md" "ox-md.el"
+;;;;;;  (0 0 0 0))
+;;; Generated autoloads from ox-md.el
+
+(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "ox-md" '("org-md-")))
+
 ;;;***
 
 ;;;### (autoloads "actual autoloads are elsewhere" "ox-odt" "ox-odt.el"
@@ -1682,6 +1698,14 @@ Inserted by installing Org or when a release is made.
 
 (if (fboundp 'register-definition-prefixes) (register-definition-prefixes "ox-odt" '("org-odt-")))
 
+;;;***
+
+;;;### (autoloads "actual autoloads are elsewhere" "ox-org" "ox-org.el"
+;;;;;;  (0 0 0 0))
+;;; Generated autoloads from ox-org.el
+
+(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "ox-org" '("org-org-")))
+
 ;;;***
 
 ;;;### (autoloads "actual autoloads are elsewhere" "ox-publish" "ox-publish.el"
diff --git a/elpa/org-9.3.2/org-capture.el b/elpa/org-9.3.3/org-capture.el
similarity index 99%
rename from elpa/org-9.3.2/org-capture.el
rename to elpa/org-9.3.3/org-capture.el
index d4921c04..2d5e2f13 100644
--- a/elpa/org-9.3.2/org-capture.el
+++ b/elpa/org-9.3.3/org-capture.el
@@ -236,15 +236,15 @@ properties are:
 
  :jump-to-captured   When set, jump to the captured entry when finished.
 
- :empty-lines        Set this to the number of lines the should be inserted
+ :empty-lines        Set this to the number of lines that should be inserted
                      before and after the new item.  Default 0, only common
                      other value is 1.
 
- :empty-lines-before Set this to the number of lines the should be inserted
+ :empty-lines-before Set this to the number of lines that should be inserted
                      before the new item.  Overrides :empty-lines for the
                      number lines inserted before.
 
- :empty-lines-after  Set this to the number of lines the should be inserted
+ :empty-lines-after  Set this to the number of lines that should be inserted
                      after the new item.  Overrides :empty-lines for the
                      number of lines inserted after.
 
@@ -1148,14 +1148,13 @@ may have been stored before."
 	  (when insert-here? (narrow-to-region beg beg))
 	  (org-paste-subtree level template 'for-yank))
 	(org-capture-position-for-last-stored beg)
-	(let ((end (if (org-at-heading-p) (line-end-position 0) (point))))
-	  (org-capture-empty-lines-after)
-	  (unless (org-at-heading-p) (outline-next-heading))
-	  (org-capture-mark-kill-region origin (point))
-	  (org-capture-narrow beg end)
-	  (when (or (search-backward "%?" beg t)
-		    (search-forward "%?" end t))
-	    (replace-match "")))))))
+	(org-capture-empty-lines-after)
+	(unless (org-at-heading-p) (outline-next-heading))
+	(org-capture-mark-kill-region origin (point))
+	(org-capture-narrow beg (1- (point)))
+	(when (or (search-backward "%?" beg t)
+		  (search-forward "%?" nil t))
+	  (replace-match ""))))))
 
 (defun org-capture-place-item ()
   "Place the template as a new plain list item."
diff --git a/elpa/org-9.3.2/org-capture.elc b/elpa/org-9.3.3/org-capture.elc
similarity index 80%
rename from elpa/org-9.3.2/org-capture.elc
rename to elpa/org-9.3.3/org-capture.elc
index 96ef7916..35d3aece 100644
Binary files a/elpa/org-9.3.2/org-capture.elc and b/elpa/org-9.3.3/org-capture.elc differ
diff --git a/elpa/org-9.3.2/org-clock.el b/elpa/org-9.3.3/org-clock.el
similarity index 99%
rename from elpa/org-9.3.2/org-clock.el
rename to elpa/org-9.3.3/org-clock.el
index 1e355670..a95c8543 100644
--- a/elpa/org-9.3.2/org-clock.el
+++ b/elpa/org-9.3.3/org-clock.el
@@ -808,6 +808,7 @@ If PLAY-SOUND is non-nil, it overrides `org-clock-sound'."
   "Show notification.
 Use `org-show-notification-handler' if defined,
 use libnotify if available, or fall back on a message."
+  (ignore-errors (require 'notifications))
   (cond ((functionp org-show-notification-handler)
 	 (funcall org-show-notification-handler notification))
 	((stringp org-show-notification-handler)
@@ -823,11 +824,6 @@ use libnotify if available, or fall back on a message."
 	((executable-find "notify-send")
 	 (start-process "emacs-timer-notification" nil
 			"notify-send" notification))
-	((string-equal system-type "windows-nt")
-	 (w32-notification-close (w32-notification-notify
-				  :title "Org mode message"
-				  :body notification
-				  :urgency 'low)))
 	;; Maybe the handler will send a message, so only use message as
 	;; a fall back option
 	(t (message "%s" notification))))
diff --git a/elpa/org-9.3.2/org-clock.elc b/elpa/org-9.3.3/org-clock.elc
similarity index 96%
rename from elpa/org-9.3.2/org-clock.elc
rename to elpa/org-9.3.3/org-clock.elc
index c4c52528..f91885b0 100644
Binary files a/elpa/org-9.3.2/org-clock.elc and b/elpa/org-9.3.3/org-clock.elc differ
diff --git a/elpa/org-9.3.2/org-colview.el b/elpa/org-9.3.3/org-colview.el
similarity index 100%
rename from elpa/org-9.3.2/org-colview.el
rename to elpa/org-9.3.3/org-colview.el
diff --git a/elpa/org-9.3.2/org-colview.elc b/elpa/org-9.3.3/org-colview.elc
similarity index 100%
rename from elpa/org-9.3.2/org-colview.elc
rename to elpa/org-9.3.3/org-colview.elc
diff --git a/elpa/org-9.3.2/org-compat.el b/elpa/org-9.3.3/org-compat.el
similarity index 100%
rename from elpa/org-9.3.2/org-compat.el
rename to elpa/org-9.3.3/org-compat.el
diff --git a/elpa/org-9.3.2/org-compat.elc b/elpa/org-9.3.3/org-compat.elc
similarity index 100%
rename from elpa/org-9.3.2/org-compat.elc
rename to elpa/org-9.3.3/org-compat.elc
diff --git a/elpa/org-9.3.2/org-crypt.el b/elpa/org-9.3.3/org-crypt.el
similarity index 100%
rename from elpa/org-9.3.2/org-crypt.el
rename to elpa/org-9.3.3/org-crypt.el
diff --git a/elpa/org-9.3.2/org-crypt.elc b/elpa/org-9.3.3/org-crypt.elc
similarity index 100%
rename from elpa/org-9.3.2/org-crypt.elc
rename to elpa/org-9.3.3/org-crypt.elc
diff --git a/elpa/org-9.3.2/org-ctags.el b/elpa/org-9.3.3/org-ctags.el
similarity index 100%
rename from elpa/org-9.3.2/org-ctags.el
rename to elpa/org-9.3.3/org-ctags.el
diff --git a/elpa/org-9.3.2/org-ctags.elc b/elpa/org-9.3.3/org-ctags.elc
similarity index 100%
rename from elpa/org-9.3.2/org-ctags.elc
rename to elpa/org-9.3.3/org-ctags.elc
diff --git a/elpa/org-9.3.2/org-datetree.el b/elpa/org-9.3.3/org-datetree.el
similarity index 100%
rename from elpa/org-9.3.2/org-datetree.el
rename to elpa/org-9.3.3/org-datetree.el
diff --git a/elpa/org-9.3.2/org-datetree.elc b/elpa/org-9.3.3/org-datetree.elc
similarity index 100%
rename from elpa/org-9.3.2/org-datetree.elc
rename to elpa/org-9.3.3/org-datetree.elc
diff --git a/elpa/org-9.3.2/org-duration.el b/elpa/org-9.3.3/org-duration.el
similarity index 100%
rename from elpa/org-9.3.2/org-duration.el
rename to elpa/org-9.3.3/org-duration.el
diff --git a/elpa/org-9.3.2/org-duration.elc b/elpa/org-9.3.3/org-duration.elc
similarity index 100%
rename from elpa/org-9.3.2/org-duration.elc
rename to elpa/org-9.3.3/org-duration.elc
diff --git a/elpa/org-9.3.2/org-element.el b/elpa/org-9.3.3/org-element.el
similarity index 100%
rename from elpa/org-9.3.2/org-element.el
rename to elpa/org-9.3.3/org-element.el
diff --git a/elpa/org-9.3.2/org-element.elc b/elpa/org-9.3.3/org-element.elc
similarity index 100%
rename from elpa/org-9.3.2/org-element.elc
rename to elpa/org-9.3.3/org-element.elc
diff --git a/elpa/org-9.3.2/org-entities.el b/elpa/org-9.3.3/org-entities.el
similarity index 100%
rename from elpa/org-9.3.2/org-entities.el
rename to elpa/org-9.3.3/org-entities.el
diff --git a/elpa/org-9.3.2/org-entities.elc b/elpa/org-9.3.3/org-entities.elc
similarity index 100%
rename from elpa/org-9.3.2/org-entities.elc
rename to elpa/org-9.3.3/org-entities.elc
diff --git a/elpa/org-9.3.2/org-faces.el b/elpa/org-9.3.3/org-faces.el
similarity index 100%
rename from elpa/org-9.3.2/org-faces.el
rename to elpa/org-9.3.3/org-faces.el
diff --git a/elpa/org-9.3.2/org-faces.elc b/elpa/org-9.3.3/org-faces.elc
similarity index 100%
rename from elpa/org-9.3.2/org-faces.elc
rename to elpa/org-9.3.3/org-faces.elc
diff --git a/elpa/org-9.3.2/org-feed.el b/elpa/org-9.3.3/org-feed.el
similarity index 100%
rename from elpa/org-9.3.2/org-feed.el
rename to elpa/org-9.3.3/org-feed.el
diff --git a/elpa/org-9.3.2/org-feed.elc b/elpa/org-9.3.3/org-feed.elc
similarity index 100%
rename from elpa/org-9.3.2/org-feed.elc
rename to elpa/org-9.3.3/org-feed.elc
diff --git a/elpa/org-9.3.2/org-footnote.el b/elpa/org-9.3.3/org-footnote.el
similarity index 100%
rename from elpa/org-9.3.2/org-footnote.el
rename to elpa/org-9.3.3/org-footnote.el
diff --git a/elpa/org-9.3.2/org-footnote.elc b/elpa/org-9.3.3/org-footnote.elc
similarity index 100%
rename from elpa/org-9.3.2/org-footnote.elc
rename to elpa/org-9.3.3/org-footnote.elc
diff --git a/elpa/org-9.3.2/org-goto.el b/elpa/org-9.3.3/org-goto.el
similarity index 100%
rename from elpa/org-9.3.2/org-goto.el
rename to elpa/org-9.3.3/org-goto.el
diff --git a/elpa/org-9.3.2/org-goto.elc b/elpa/org-9.3.3/org-goto.elc
similarity index 100%
rename from elpa/org-9.3.2/org-goto.elc
rename to elpa/org-9.3.3/org-goto.elc
diff --git a/elpa/org-9.3.2/org-habit.el b/elpa/org-9.3.3/org-habit.el
similarity index 100%
rename from elpa/org-9.3.2/org-habit.el
rename to elpa/org-9.3.3/org-habit.el
diff --git a/elpa/org-9.3.2/org-habit.elc b/elpa/org-9.3.3/org-habit.elc
similarity index 100%
rename from elpa/org-9.3.2/org-habit.elc
rename to elpa/org-9.3.3/org-habit.elc
diff --git a/elpa/org-9.3.2/org-id.el b/elpa/org-9.3.3/org-id.el
similarity index 100%
rename from elpa/org-9.3.2/org-id.el
rename to elpa/org-9.3.3/org-id.el
diff --git a/elpa/org-9.3.2/org-id.elc b/elpa/org-9.3.3/org-id.elc
similarity index 100%
rename from elpa/org-9.3.2/org-id.elc
rename to elpa/org-9.3.3/org-id.elc
diff --git a/elpa/org-9.3.2/org-indent.el b/elpa/org-9.3.3/org-indent.el
similarity index 100%
rename from elpa/org-9.3.2/org-indent.el
rename to elpa/org-9.3.3/org-indent.el
diff --git a/elpa/org-9.3.2/org-indent.elc b/elpa/org-9.3.3/org-indent.elc
similarity index 100%
rename from elpa/org-9.3.2/org-indent.elc
rename to elpa/org-9.3.3/org-indent.elc
diff --git a/elpa/org-9.3.2/org-inlinetask.el b/elpa/org-9.3.3/org-inlinetask.el
similarity index 100%
rename from elpa/org-9.3.2/org-inlinetask.el
rename to elpa/org-9.3.3/org-inlinetask.el
diff --git a/elpa/org-9.3.2/org-inlinetask.elc b/elpa/org-9.3.3/org-inlinetask.elc
similarity index 100%
rename from elpa/org-9.3.2/org-inlinetask.elc
rename to elpa/org-9.3.3/org-inlinetask.elc
diff --git a/elpa/org-9.3.2/org-install.el b/elpa/org-9.3.3/org-install.el
similarity index 100%
rename from elpa/org-9.3.2/org-install.el
rename to elpa/org-9.3.3/org-install.el
diff --git a/elpa/org-9.3.2/org-keys.el b/elpa/org-9.3.3/org-keys.el
similarity index 100%
rename from elpa/org-9.3.2/org-keys.el
rename to elpa/org-9.3.3/org-keys.el
diff --git a/elpa/org-9.3.2/org-keys.elc b/elpa/org-9.3.3/org-keys.elc
similarity index 100%
rename from elpa/org-9.3.2/org-keys.elc
rename to elpa/org-9.3.3/org-keys.elc
diff --git a/elpa/org-9.3.2/org-lint.el b/elpa/org-9.3.3/org-lint.el
similarity index 100%
rename from elpa/org-9.3.2/org-lint.el
rename to elpa/org-9.3.3/org-lint.el
diff --git a/elpa/org-9.3.2/org-lint.elc b/elpa/org-9.3.3/org-lint.elc
similarity index 100%
rename from elpa/org-9.3.2/org-lint.elc
rename to elpa/org-9.3.3/org-lint.elc
diff --git a/elpa/org-9.3.2/org-list.el b/elpa/org-9.3.3/org-list.el
similarity index 100%
rename from elpa/org-9.3.2/org-list.el
rename to elpa/org-9.3.3/org-list.el
diff --git a/elpa/org-9.3.2/org-list.elc b/elpa/org-9.3.3/org-list.elc
similarity index 100%
rename from elpa/org-9.3.2/org-list.elc
rename to elpa/org-9.3.3/org-list.elc
diff --git a/elpa/org-9.3.2/org-loaddefs.el b/elpa/org-9.3.3/org-loaddefs.el
similarity index 99%
rename from elpa/org-9.3.2/org-loaddefs.el
rename to elpa/org-9.3.3/org-loaddefs.el
index bebb25c3..789a2898 100644
--- a/elpa/org-9.3.2/org-loaddefs.el
+++ b/elpa/org-9.3.3/org-loaddefs.el
@@ -453,7 +453,7 @@ Mark current source block.
 
 ;;;***
 
-;;;### (autoloads nil "ob-lob" "ob-lob.el" (0 0 0 0))
+;;;### (autoloads nil "ob-lob" "ob-lob.el" "6d57273b1605eda4687aec918974697a")
 ;;; Generated autoloads from ob-lob.el
 
 (autoload 'org-babel-lob-execute-maybe "ob-lob" "\
@@ -474,8 +474,6 @@ see.
 
 \(fn &optional DATUM)" nil nil)
 
-(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "ob-lob" '("org-babel-")))
-
 ;;;***
 
 ;;;### (autoloads nil "ob-lua" "ob-lua.el" (0 0 0 0))
@@ -1039,7 +1037,7 @@ This command is set with the variable `org-archive-default-command'.
 
 ;;;***
 
-;;;### (autoloads nil "org-attach" "org-attach.el" "6571ad3471b5b19700e2187c3a8875a1")
+;;;### (autoloads nil "org-attach" "org-attach.el" "615f9751ee146d0bc438026f3fbc667a")
 ;;; Generated autoloads from org-attach.el
 
 (autoload 'org-attach "org-attach" "\
@@ -1135,7 +1133,7 @@ Set `org-capture-templates' to be similar to `org-remember-templates'.
 
 ;;;***
 
-;;;### (autoloads nil "org-clock" "org-clock.el" "eb7dcac30e5ee869a0a17d10fa6744c8")
+;;;### (autoloads nil "org-clock" "org-clock.el" "8c8b1bb5031994b56517e9f4b4d375a3")
 ;;; Generated autoloads from org-clock.el
 
 (autoload 'org-resolve-clocks "org-clock" "\
@@ -1928,7 +1926,7 @@ line directly before or after the table.
 
 ;;;***
 
-;;;### (autoloads nil "org-table" "org-table.el" "af0351b12f157700c254ac5230eee895")
+;;;### (autoloads nil "org-table" "org-table.el" "e03bdb677af1e59dd1f88412075b97a5")
 ;;; Generated autoloads from org-table.el
 
 (autoload 'org-table-create-with-table\.el "org-table" "\
@@ -3737,7 +3735,7 @@ Return output file name.
 
 ;;;***
 
-;;;### (autoloads nil "ox-md" "ox-md.el" (0 0 0 0))
+;;;### (autoloads nil "ox-md" "ox-md.el" "4ab99e949dbf6e3155ba97413135a505")
 ;;; Generated autoloads from ox-md.el
 
 (autoload 'org-md-export-as-markdown "ox-md" "\
@@ -3807,11 +3805,9 @@ Return output file name.
 
 \(fn PLIST FILENAME PUB-DIR)" nil nil)
 
-(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "ox-md" '("org-md-")))
-
 ;;;***
 
-;;;### (autoloads nil "ox-odt" "ox-odt.el" "f93435c1ea4d02b23b8bb4fabbeaba8e")
+;;;### (autoloads nil "ox-odt" "ox-odt.el" "32287546c7bcd83afbd3574f88226286")
 ;;; Generated autoloads from ox-odt.el
 
 (put 'org-odt-preferred-output-format 'safe-local-variable 'stringp)
@@ -3873,7 +3869,7 @@ is non-nil then the newly converted file is opened using
 
 ;;;***
 
-;;;### (autoloads nil "ox-org" "ox-org.el" (0 0 0 0))
+;;;### (autoloads nil "ox-org" "ox-org.el" "80543be9a4dc90f660e5cdded24f4ce7")
 ;;; Generated autoloads from ox-org.el
 
 (autoload 'org-org-export-as-org "ox-org" "\
@@ -3949,8 +3945,6 @@ Return output file name.
 
 \(fn PLIST FILENAME PUB-DIR)" nil nil)
 
-(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "ox-org" '("org-org-")))
-
 ;;;***
 
 ;;;### (autoloads nil "ox-publish" "ox-publish.el" "874b7fbc7347bb5ec0f7da70a299312f")
diff --git a/elpa/org-9.3.2/org-macro.el b/elpa/org-9.3.3/org-macro.el
similarity index 100%
rename from elpa/org-9.3.2/org-macro.el
rename to elpa/org-9.3.3/org-macro.el
diff --git a/elpa/org-9.3.2/org-macro.elc b/elpa/org-9.3.3/org-macro.elc
similarity index 100%
rename from elpa/org-9.3.2/org-macro.elc
rename to elpa/org-9.3.3/org-macro.elc
diff --git a/elpa/org-9.3.2/org-macs.el b/elpa/org-9.3.3/org-macs.el
similarity index 99%
rename from elpa/org-9.3.2/org-macs.el
rename to elpa/org-9.3.3/org-macs.el
index 4a40765e..a98f0c08 100644
--- a/elpa/org-9.3.2/org-macs.el
+++ b/elpa/org-9.3.3/org-macs.el
@@ -416,6 +416,7 @@ is selected, only the bare key is returned."
     (let ((inhibit-quit t)
 	  (buffer (org-switch-to-buffer-other-window "*Org Select*"))
 	  (prompt (or prompt "Select: "))
+	  case-fold-search
 	  current)
       (unwind-protect
 	  (catch 'exit
diff --git a/elpa/org-9.3.2/org-macs.elc b/elpa/org-9.3.3/org-macs.elc
similarity index 88%
rename from elpa/org-9.3.2/org-macs.elc
rename to elpa/org-9.3.3/org-macs.elc
index 439a0ae5..4345a376 100644
Binary files a/elpa/org-9.3.2/org-macs.elc and b/elpa/org-9.3.3/org-macs.elc differ
diff --git a/elpa/org-9.3.2/org-mobile.el b/elpa/org-9.3.3/org-mobile.el
similarity index 100%
rename from elpa/org-9.3.2/org-mobile.el
rename to elpa/org-9.3.3/org-mobile.el
diff --git a/elpa/org-9.3.2/org-mobile.elc b/elpa/org-9.3.3/org-mobile.elc
similarity index 100%
rename from elpa/org-9.3.2/org-mobile.elc
rename to elpa/org-9.3.3/org-mobile.elc
diff --git a/elpa/org-9.3.2/org-mouse.el b/elpa/org-9.3.3/org-mouse.el
similarity index 100%
rename from elpa/org-9.3.2/org-mouse.el
rename to elpa/org-9.3.3/org-mouse.el
diff --git a/elpa/org-9.3.2/org-mouse.elc b/elpa/org-9.3.3/org-mouse.elc
similarity index 100%
rename from elpa/org-9.3.2/org-mouse.elc
rename to elpa/org-9.3.3/org-mouse.elc
diff --git a/elpa/org-9.3.2/org-num.el b/elpa/org-9.3.3/org-num.el
similarity index 100%
rename from elpa/org-9.3.2/org-num.el
rename to elpa/org-9.3.3/org-num.el
diff --git a/elpa/org-9.3.2/org-num.elc b/elpa/org-9.3.3/org-num.elc
similarity index 100%
rename from elpa/org-9.3.2/org-num.elc
rename to elpa/org-9.3.3/org-num.elc
diff --git a/elpa/org-9.3.2/org-pcomplete.el b/elpa/org-9.3.3/org-pcomplete.el
similarity index 100%
rename from elpa/org-9.3.2/org-pcomplete.el
rename to elpa/org-9.3.3/org-pcomplete.el
diff --git a/elpa/org-9.3.2/org-pcomplete.elc b/elpa/org-9.3.3/org-pcomplete.elc
similarity index 100%
rename from elpa/org-9.3.2/org-pcomplete.elc
rename to elpa/org-9.3.3/org-pcomplete.elc
diff --git a/elpa/org-9.3.2/org-pkg.el b/elpa/org-9.3.3/org-pkg.el
similarity index 55%
rename from elpa/org-9.3.2/org-pkg.el
rename to elpa/org-9.3.3/org-pkg.el
index 270b21da..0024ecb5 100644
--- a/elpa/org-9.3.2/org-pkg.el
+++ b/elpa/org-9.3.3/org-pkg.el
@@ -1,2 +1,2 @@
 ;; Generated package description from org.el  -*- no-byte-compile: t -*-
-(define-package "org" "9.3.2" "Outline-based notes management and organizer" 'nil :keywords '("outlines" "hypermedia" "calendar" "wp") :authors '(("Carsten Dominik <carsten at orgmode dot org>")) :maintainer '("Carsten Dominik <carsten at orgmode dot org>") :url "https://orgmode.org")
+(define-package "org" "9.3.3" "Outline-based notes management and organizer" 'nil :keywords '("outlines" "hypermedia" "calendar" "wp") :authors '(("Carsten Dominik <carsten at orgmode dot org>")) :maintainer '("Bastien Guerry" . "bzg@gnu.org") :url "https://orgmode.org")
diff --git a/elpa/org-9.3.2/org-plot.el b/elpa/org-9.3.3/org-plot.el
similarity index 100%
rename from elpa/org-9.3.2/org-plot.el
rename to elpa/org-9.3.3/org-plot.el
diff --git a/elpa/org-9.3.2/org-plot.elc b/elpa/org-9.3.3/org-plot.elc
similarity index 100%
rename from elpa/org-9.3.2/org-plot.elc
rename to elpa/org-9.3.3/org-plot.elc
diff --git a/elpa/org-9.3.2/org-protocol.el b/elpa/org-9.3.3/org-protocol.el
similarity index 100%
rename from elpa/org-9.3.2/org-protocol.el
rename to elpa/org-9.3.3/org-protocol.el
diff --git a/elpa/org-9.3.2/org-protocol.elc b/elpa/org-9.3.3/org-protocol.elc
similarity index 100%
rename from elpa/org-9.3.2/org-protocol.elc
rename to elpa/org-9.3.3/org-protocol.elc
diff --git a/elpa/org-9.3.2/org-src.el b/elpa/org-9.3.3/org-src.el
similarity index 100%
rename from elpa/org-9.3.2/org-src.el
rename to elpa/org-9.3.3/org-src.el
diff --git a/elpa/org-9.3.2/org-src.elc b/elpa/org-9.3.3/org-src.elc
similarity index 100%
rename from elpa/org-9.3.2/org-src.elc
rename to elpa/org-9.3.3/org-src.elc
diff --git a/elpa/org-9.3.2/org-table.el b/elpa/org-9.3.3/org-table.el
similarity index 98%
rename from elpa/org-9.3.2/org-table.el
rename to elpa/org-9.3.3/org-table.el
index 49765472..63b2288e 100644
--- a/elpa/org-9.3.2/org-table.el
+++ b/elpa/org-9.3.3/org-table.el
@@ -2578,27 +2578,29 @@ location of point."
 		     ev)))
 
 	(when org-table-formula-debug
-	  (with-output-to-temp-buffer "*Substitution History*"
-	    (princ (format "Substitution history of formula
+	  (let ((wcf (current-window-configuration)))
+	    (with-output-to-temp-buffer "*Substitution History*"
+	      (princ (format "Substitution history of formula
 Orig:   %s
 $xyz->  %s
 @r$c->  %s
 $1->    %s\n" orig formula form0 form))
-	    (if (consp ev)
-		(princ (format "        %s^\nError:  %s"
-			       (make-string (car ev) ?\-) (nth 1 ev)))
-	      (princ (format "Result: %s\nFormat: %s\nFinal:  %s"
-			     ev (or fmt "NONE")
-			     (if fmt (format fmt (string-to-number ev)) ev)))))
-	  (setq bw (get-buffer-window "*Substitution History*"))
-	  (org-fit-window-to-buffer bw)
-	  (unless (and (called-interactively-p 'any) (not ndown))
-	    (unless (let (inhibit-redisplay)
-		      (y-or-n-p "Debugging Formula.  Continue to next? "))
-	      (org-table-align)
-	      (user-error "Abort"))
-	    (delete-window bw)
-	    (message "")))
+	      (if (consp ev)
+		  (princ (format "        %s^\nError:  %s"
+				 (make-string (car ev) ?\-) (nth 1 ev)))
+		(princ (format "Result: %s\nFormat: %s\nFinal:  %s"
+			       ev (or fmt "NONE")
+			       (if fmt (format fmt (string-to-number ev)) ev)))))
+	    (setq bw (get-buffer-window "*Substitution History*"))
+	    (org-fit-window-to-buffer bw)
+	    (unless (and (called-interactively-p 'any) (not ndown))
+	      (unless (let (inhibit-redisplay)
+			(y-or-n-p "Debugging Formula.  Continue to next? "))
+		(org-table-align)
+		(user-error "Abort"))
+	      (delete-window bw)
+	      (message "")
+	      (set-window-configuration wcf))))
 	(when (consp ev) (setq fmt nil ev "#ERROR"))
 	(org-table-justify-field-maybe
 	 (format org-table-formula-field-format
@@ -3768,14 +3770,16 @@ FACE, when non-nil, for the highlight."
 (defun org-table-toggle-coordinate-overlays ()
   "Toggle the display of Row/Column numbers in tables."
   (interactive)
-  (setq org-table-overlay-coordinates (not org-table-overlay-coordinates))
-  (message "Tables Row/Column numbers display turned %s"
-	   (if org-table-overlay-coordinates "on" "off"))
-  (when (and (org-at-table-p) org-table-overlay-coordinates)
-    (org-table-align))
-  (unless org-table-overlay-coordinates
-    (mapc 'delete-overlay org-table-coordinate-overlays)
-    (setq org-table-coordinate-overlays nil)))
+  (if (not (org-at-table-p))
+      (user-error "Not on a table")
+    (setq org-table-overlay-coordinates (not org-table-overlay-coordinates))
+    (when (and (org-at-table-p) org-table-overlay-coordinates)
+      (org-table-align))
+    (unless org-table-overlay-coordinates
+      (mapc 'delete-overlay org-table-coordinate-overlays)
+      (setq org-table-coordinate-overlays nil))
+    (message "Tables Row/Column numbers display turned %s"
+	     (if org-table-overlay-coordinates "on" "off"))))
 
 ;;;###autoload
 (defun org-table-toggle-formula-debugger ()
@@ -5039,66 +5043,66 @@ When LOCAL is non-nil, show references for the table at point."
 (put 'orgtbl-mode :menu-tag "Org Table Mode")
 
 (easy-menu-define orgtbl-mode-menu orgtbl-mode-map "OrgTbl menu"
-      '("OrgTbl"
-	["Create or convert" org-table-create-or-convert-from-region
-	 :active (not (org-at-table-p)) :keys "C-c |" ]
-	"--"
-	["Align" org-ctrl-c-ctrl-c :active (org-at-table-p) :keys "C-c C-c"]
-	["Next Field" org-cycle :active (org-at-table-p) :keys "TAB"]
-	["Previous Field" org-shifttab :active (org-at-table-p) :keys "S-TAB"]
-	["Next Row" org-return :active (org-at-table-p) :keys "RET"]
-	"--"
-	["Blank Field" org-table-blank-field :active (org-at-table-p) :keys "C-c SPC"]
-	["Edit Field" org-table-edit-field :active (org-at-table-p) :keys "C-c ` "]
-	["Copy Field from Above"
-	 org-table-copy-down :active (org-at-table-p) :keys "S-RET"]
-	"--"
-	("Column"
-	 ["Move Column Left" org-metaleft :active (org-at-table-p) :keys "M-<left>"]
-	 ["Move Column Right" org-metaright :active (org-at-table-p) :keys "M-<right>"]
-	 ["Delete Column" org-shiftmetaleft :active (org-at-table-p) :keys "M-S-<left>"]
-	 ["Insert Column" org-shiftmetaright :active (org-at-table-p) :keys "M-S-<right>"])
-	("Row"
-	 ["Move Row Up" org-metaup :active (org-at-table-p) :keys "M-<up>"]
-	 ["Move Row Down" org-metadown :active (org-at-table-p) :keys "M-<down>"]
-	 ["Delete Row" org-shiftmetaup :active (org-at-table-p) :keys "M-S-<up>"]
-	 ["Insert Row" org-shiftmetadown :active (org-at-table-p) :keys "M-S-<down>"]
-	 ["Sort lines in region" org-table-sort-lines :active (org-at-table-p) :keys "C-c ^"]
-	 "--"
-	 ["Insert Hline" org-table-insert-hline :active (org-at-table-p) :keys "C-c -"])
-	("Rectangle"
-	 ["Copy Rectangle" org-copy-special :active (org-at-table-p)]
-	 ["Cut Rectangle" org-cut-special :active (org-at-table-p)]
-	 ["Paste Rectangle" org-paste-special :active (org-at-table-p)]
-	 ["Fill Rectangle" org-table-wrap-region :active (org-at-table-p)])
-	"--"
-	("Radio tables"
-	 ["Insert table template" orgtbl-insert-radio-table
-	  (cl-assoc-if #'derived-mode-p orgtbl-radio-table-templates)]
-	 ["Comment/uncomment table" orgtbl-toggle-comment t])
-	"--"
-	["Set Column Formula" org-table-eval-formula :active (org-at-table-p) :keys "C-c ="]
-	["Set Field Formula" (org-table-eval-formula '(4)) :active (org-at-table-p) :keys "C-u C-c ="]
-	["Edit Formulas" org-table-edit-formulas :active (org-at-table-p) :keys "C-c '"]
-	["Recalculate line" org-table-recalculate :active (org-at-table-p) :keys "C-c *"]
-	["Recalculate all" (org-table-recalculate '(4)) :active (org-at-table-p) :keys "C-u C-c *"]
-	["Iterate all" (org-table-recalculate '(16)) :active (org-at-table-p) :keys "C-u C-u C-c *"]
-	["Toggle Recalculate Mark" org-table-rotate-recalc-marks :active (org-at-table-p) :keys "C-c #"]
-	["Sum Column/Rectangle" org-table-sum
-	 :active (or (org-at-table-p) (org-region-active-p)) :keys "C-c +"]
-	["Which Column?" org-table-current-column :active (org-at-table-p) :keys "C-c ?"]
-	["Debug Formulas"
-	 org-table-toggle-formula-debugger :active (org-at-table-p)
-	 :keys "C-c {"
-	 :style toggle :selected org-table-formula-debug]
-	["Show Col/Row Numbers"
-	 org-table-toggle-coordinate-overlays :active (org-at-table-p)
-	 :keys "C-c }"
-	 :style toggle :selected org-table-overlay-coordinates]
-	"--"
-	("Plot"
-	 ["Ascii plot" orgtbl-ascii-plot :active (org-at-table-p) :keys "C-c \" a"]
-	 ["Gnuplot" org-plot/gnuplot :active (org-at-table-p) :keys "C-c \" g"])))
+  '("OrgTbl"
+    ["Create or convert" org-table-create-or-convert-from-region
+     :active (not (org-at-table-p)) :keys "C-c |" ]
+    "--"
+    ["Align" org-ctrl-c-ctrl-c :active (org-at-table-p) :keys "C-c C-c"]
+    ["Next Field" org-cycle :active (org-at-table-p) :keys "TAB"]
+    ["Previous Field" org-shifttab :active (org-at-table-p) :keys "S-TAB"]
+    ["Next Row" org-return :active (org-at-table-p) :keys "RET"]
+    "--"
+    ["Blank Field" org-table-blank-field :active (org-at-table-p) :keys "C-c SPC"]
+    ["Edit Field" org-table-edit-field :active (org-at-table-p) :keys "C-c ` "]
+    ["Copy Field from Above"
+     org-table-copy-down :active (org-at-table-p) :keys "S-RET"]
+    "--"
+    ("Column"
+     ["Move Column Left" org-metaleft :active (org-at-table-p) :keys "M-<left>"]
+     ["Move Column Right" org-metaright :active (org-at-table-p) :keys "M-<right>"]
+     ["Delete Column" org-shiftmetaleft :active (org-at-table-p) :keys "M-S-<left>"]
+     ["Insert Column" org-shiftmetaright :active (org-at-table-p) :keys "M-S-<right>"])
+    ("Row"
+     ["Move Row Up" org-metaup :active (org-at-table-p) :keys "M-<up>"]
+     ["Move Row Down" org-metadown :active (org-at-table-p) :keys "M-<down>"]
+     ["Delete Row" org-shiftmetaup :active (org-at-table-p) :keys "M-S-<up>"]
+     ["Insert Row" org-shiftmetadown :active (org-at-table-p) :keys "M-S-<down>"]
+     ["Sort lines in region" org-table-sort-lines :active (org-at-table-p) :keys "C-c ^"]
+     "--"
+     ["Insert Hline" org-table-insert-hline :active (org-at-table-p) :keys "C-c -"])
+    ("Rectangle"
+     ["Copy Rectangle" org-copy-special :active (org-at-table-p)]
+     ["Cut Rectangle" org-cut-special :active (org-at-table-p)]
+     ["Paste Rectangle" org-paste-special :active (org-at-table-p)]
+     ["Fill Rectangle" org-table-wrap-region :active (org-at-table-p)])
+    "--"
+    ("Radio tables"
+     ["Insert table template" orgtbl-insert-radio-table
+      (cl-assoc-if #'derived-mode-p orgtbl-radio-table-templates)]
+     ["Comment/uncomment table" orgtbl-toggle-comment t])
+    "--"
+    ["Set Column Formula" org-table-eval-formula :active (org-at-table-p) :keys "C-c ="]
+    ["Set Field Formula" (org-table-eval-formula '(4)) :active (org-at-table-p) :keys "C-u C-c ="]
+    ["Edit Formulas" org-table-edit-formulas :active (org-at-table-p) :keys "C-c '"]
+    ["Recalculate line" org-table-recalculate :active (org-at-table-p) :keys "C-c *"]
+    ["Recalculate all" (org-table-recalculate '(4)) :active (org-at-table-p) :keys "C-u C-c *"]
+    ["Iterate all" (org-table-recalculate '(16)) :active (org-at-table-p) :keys "C-u C-u C-c *"]
+    ["Toggle Recalculate Mark" org-table-rotate-recalc-marks :active (org-at-table-p) :keys "C-c #"]
+    ["Sum Column/Rectangle" org-table-sum
+     :active (or (org-at-table-p) (org-region-active-p)) :keys "C-c +"]
+    ["Which Column?" org-table-current-column :active (org-at-table-p) :keys "C-c ?"]
+    ["Debug Formulas"
+     org-table-toggle-formula-debugger :active (org-at-table-p)
+     :keys "C-c {"
+     :style toggle :selected org-table-formula-debug]
+    ["Show Col/Row Numbers"
+     org-table-toggle-coordinate-overlays :active (org-at-table-p)
+     :keys "C-c }"
+     :style toggle :selected org-table-overlay-coordinates]
+    "--"
+    ("Plot"
+     ["Ascii plot" orgtbl-ascii-plot :active (org-at-table-p) :keys "C-c \" a"]
+     ["Gnuplot" org-plot/gnuplot :active (org-at-table-p) :keys "C-c \" g"])))
 
 ;;;###autoload
 (define-minor-mode orgtbl-mode
diff --git a/elpa/org-9.3.2/org-table.elc b/elpa/org-9.3.3/org-table.elc
similarity index 95%
rename from elpa/org-9.3.2/org-table.elc
rename to elpa/org-9.3.3/org-table.elc
index 1324ae67..f4fe8c44 100644
Binary files a/elpa/org-9.3.2/org-table.elc and b/elpa/org-9.3.3/org-table.elc differ
diff --git a/elpa/org-9.3.2/org-tempo.el b/elpa/org-9.3.3/org-tempo.el
similarity index 99%
rename from elpa/org-9.3.2/org-tempo.el
rename to elpa/org-9.3.3/org-tempo.el
index 9ae27005..e6171c70 100644
--- a/elpa/org-9.3.2/org-tempo.el
+++ b/elpa/org-9.3.3/org-tempo.el
@@ -122,7 +122,7 @@ Go through `org-structure-template-alist' and
 	 (special (member name '("src" "export"))))
     (tempo-define-template (format "org-%s" (replace-regexp-in-string " " "-" name))
 			   `(,(format "#+begin_%s%s" name (if special " " ""))
-			     ,(when special 'p) '> n '> ,(unless special 'p) n
+			     ,(when special 'p) '> n ,(unless special 'p) n
 			     ,(format "#+end_%s" (car (split-string name " ")))
 			     >)
 			   key
diff --git a/elpa/org-9.3.2/org-tempo.elc b/elpa/org-9.3.3/org-tempo.elc
similarity index 92%
rename from elpa/org-9.3.2/org-tempo.elc
rename to elpa/org-9.3.3/org-tempo.elc
index 980ea986..302a8a10 100644
Binary files a/elpa/org-9.3.2/org-tempo.elc and b/elpa/org-9.3.3/org-tempo.elc differ
diff --git a/elpa/org-9.3.2/org-timer.el b/elpa/org-9.3.3/org-timer.el
similarity index 100%
rename from elpa/org-9.3.2/org-timer.el
rename to elpa/org-9.3.3/org-timer.el
diff --git a/elpa/org-9.3.2/org-timer.elc b/elpa/org-9.3.3/org-timer.elc
similarity index 100%
rename from elpa/org-9.3.2/org-timer.elc
rename to elpa/org-9.3.3/org-timer.elc
diff --git a/elpa/org-9.3.2/org-version.el b/elpa/org-9.3.3/org-version.el
similarity index 86%
rename from elpa/org-9.3.2/org-version.el
rename to elpa/org-9.3.3/org-version.el
index 179b5f0b..66ae832a 100644
--- a/elpa/org-9.3.2/org-version.el
+++ b/elpa/org-9.3.3/org-version.el
@@ -5,13 +5,13 @@
 (defun org-release ()
   "The release version of Org.
 Inserted by installing Org mode or when a release is made."
-   (let ((org-release "9.3.2"))
+   (let ((org-release "9.3.3"))
      org-release))
 ;;;###autoload
 (defun org-git-version ()
   "The Git version of Org mode.
 Inserted by installing Org or when a release is made."
-   (let ((org-git-version "9.3.2-1-g1d426e-elpa"))
+   (let ((org-git-version "9.3.3-elpa"))
      org-git-version))
 
 (provide 'org-version)
diff --git a/elpa/org-9.3.2/org.el b/elpa/org-9.3.3/org.el
similarity index 99%
rename from elpa/org-9.3.2/org.el
rename to elpa/org-9.3.3/org.el
index 59147518..fceb894c 100644
--- a/elpa/org-9.3.2/org.el
+++ b/elpa/org-9.3.3/org.el
@@ -4,9 +4,10 @@
 ;; Copyright (C) 2004-2020 Free Software Foundation, Inc.
 ;;
 ;; Author: Carsten Dominik <carsten at orgmode dot org>
+;; Maintainer: Bastien Guerry <bzg@gnu.org>
 ;; Keywords: outlines, hypermedia, calendar, wp
 ;; Homepage: https://orgmode.org
-;; Version: 9.3.2
+;; Version: 9.3.3
 ;;
 ;; This file is part of GNU Emacs.
 ;;
@@ -413,7 +414,7 @@ Matched keyword is in group 1.")
 
 (defconst org-deadline-time-hour-regexp
   (concat "\\<" org-deadline-string
-	  " *<\\([^>]+[0-9]\\{1,2\\}:[0-9]\\{2\\}[0-9+:hdwmy \t.-]*\\)>")
+	  " *<\\([^>]+[0-9]\\{1,2\\}:[0-9]\\{2\\}[0-9+:hdwmy/ \t.-]*\\)>")
   "Matches the DEADLINE keyword together with a time-and-hour stamp.")
 
 (defconst org-deadline-line-regexp
@@ -429,7 +430,7 @@ Matched keyword is in group 1.")
 
 (defconst org-scheduled-time-hour-regexp
   (concat "\\<" org-scheduled-string
-	  " *<\\([^>]+[0-9]\\{1,2\\}:[0-9]\\{2\\}[0-9+:hdwmy \t.-]*\\)>")
+	  " *<\\([^>]+[0-9]\\{1,2\\}:[0-9]\\{2\\}[0-9+:hdwmy/ \t.-]*\\)>")
   "Matches the SCHEDULED keyword together with a time-and-hour stamp.")
 
 (defconst org-closed-time-regexp
@@ -6402,13 +6403,11 @@ Use `\\[org-edit-special]' to edit table.el tables"))
 	(setq eos (save-excursion (org-end-of-subtree t t)
 				  (when (bolp) (backward-char)) (point)))
 	(setq has-children
-	      (or (save-excursion
-		    (let ((level (funcall outline-level)))
-		      (outline-next-heading)
-		      (and (org-at-heading-p t)
-			   (> (funcall outline-level) level))))
-		  (save-excursion
-		    (org-list-search-forward (org-item-beginning-re) eos t)))))
+	      (save-excursion
+		(let ((level (funcall outline-level)))
+		  (outline-next-heading)
+		  (and (org-at-heading-p t)
+		       (> (funcall outline-level) level))))))
       ;; Determine end invisible part of buffer (EOL)
       (beginning-of-line 2)
       (while (and (not (eobp)) ;This is like `next-line'.
@@ -8682,8 +8681,7 @@ a link."
        ((memq type '(headline inlinetask))
 	(org-match-line org-complex-heading-regexp)
 	(let ((tags-beg (match-beginning 5))
-	      (tags-end (match-end 5))
-	      (tags-str (match-string 5)))
+	      (tags-end (match-end 5)))
 	  (if (and tags-beg (>= (point) tags-beg) (< (point) tags-end))
 	      ;; On tags.
 	      (org-tags-view
@@ -11578,8 +11576,6 @@ from the `before-change-functions' in the current buffer."
 (defvar org-priority-regexp ".*?\\(\\[#\\([A-Z0-9]\\)\\] ?\\)"
   "Regular expression matching the priority indicator.")
 
-(defvar org-remove-priority-next-time nil)
-
 (defun org-priority-up ()
   "Increase the priority of the current item."
   (interactive)
@@ -19284,7 +19280,7 @@ indent.  The function will not indent contents of example blocks,
 verse blocks and export blocks as leading white spaces are
 assumed to be significant there."
   (interactive "r")
-  (save-excursion
+  (save-window-excursion
     (goto-char start)
     (skip-chars-forward " \r\t\n")
     (unless (eobp) (beginning-of-line))
diff --git a/elpa/org-9.3.2/org.elc b/elpa/org-9.3.3/org.elc
similarity index 94%
rename from elpa/org-9.3.2/org.elc
rename to elpa/org-9.3.3/org.elc
index 811c8ebf..29c7f352 100644
Binary files a/elpa/org-9.3.2/org.elc and b/elpa/org-9.3.3/org.elc differ
diff --git a/elpa/org-9.3.2/orgcard.pdf b/elpa/org-9.3.3/orgcard.pdf
similarity index 92%
rename from elpa/org-9.3.2/orgcard.pdf
rename to elpa/org-9.3.3/orgcard.pdf
index 1d1f9dec..d2dc08b1 100644
Binary files a/elpa/org-9.3.2/orgcard.pdf and b/elpa/org-9.3.3/orgcard.pdf differ
diff --git a/elpa/org-9.3.2/ox-ascii.el b/elpa/org-9.3.3/ox-ascii.el
similarity index 100%
rename from elpa/org-9.3.2/ox-ascii.el
rename to elpa/org-9.3.3/ox-ascii.el
diff --git a/elpa/org-9.3.2/ox-ascii.elc b/elpa/org-9.3.3/ox-ascii.elc
similarity index 100%
rename from elpa/org-9.3.2/ox-ascii.elc
rename to elpa/org-9.3.3/ox-ascii.elc
diff --git a/elpa/org-9.3.2/ox-beamer.el b/elpa/org-9.3.3/ox-beamer.el
similarity index 100%
rename from elpa/org-9.3.2/ox-beamer.el
rename to elpa/org-9.3.3/ox-beamer.el
diff --git a/elpa/org-9.3.2/ox-beamer.elc b/elpa/org-9.3.3/ox-beamer.elc
similarity index 100%
rename from elpa/org-9.3.2/ox-beamer.elc
rename to elpa/org-9.3.3/ox-beamer.elc
diff --git a/elpa/org-9.3.2/ox-html.el b/elpa/org-9.3.3/ox-html.el
similarity index 100%
rename from elpa/org-9.3.2/ox-html.el
rename to elpa/org-9.3.3/ox-html.el
diff --git a/elpa/org-9.3.2/ox-html.elc b/elpa/org-9.3.3/ox-html.elc
similarity index 100%
rename from elpa/org-9.3.2/ox-html.elc
rename to elpa/org-9.3.3/ox-html.elc
diff --git a/elpa/org-9.3.2/ox-icalendar.el b/elpa/org-9.3.3/ox-icalendar.el
similarity index 100%
rename from elpa/org-9.3.2/ox-icalendar.el
rename to elpa/org-9.3.3/ox-icalendar.el
diff --git a/elpa/org-9.3.2/ox-icalendar.elc b/elpa/org-9.3.3/ox-icalendar.elc
similarity index 100%
rename from elpa/org-9.3.2/ox-icalendar.elc
rename to elpa/org-9.3.3/ox-icalendar.elc
diff --git a/elpa/org-9.3.2/ox-latex.el b/elpa/org-9.3.3/ox-latex.el
similarity index 100%
rename from elpa/org-9.3.2/ox-latex.el
rename to elpa/org-9.3.3/ox-latex.el
diff --git a/elpa/org-9.3.2/ox-latex.elc b/elpa/org-9.3.3/ox-latex.elc
similarity index 100%
rename from elpa/org-9.3.2/ox-latex.elc
rename to elpa/org-9.3.3/ox-latex.elc
diff --git a/elpa/org-9.3.2/ox-man.el b/elpa/org-9.3.3/ox-man.el
similarity index 100%
rename from elpa/org-9.3.2/ox-man.el
rename to elpa/org-9.3.3/ox-man.el
diff --git a/elpa/org-9.3.2/ox-man.elc b/elpa/org-9.3.3/ox-man.elc
similarity index 100%
rename from elpa/org-9.3.2/ox-man.elc
rename to elpa/org-9.3.3/ox-man.elc
diff --git a/elpa/org-9.3.2/ox-md.el b/elpa/org-9.3.3/ox-md.el
similarity index 100%
rename from elpa/org-9.3.2/ox-md.el
rename to elpa/org-9.3.3/ox-md.el
diff --git a/elpa/org-9.3.2/ox-md.elc b/elpa/org-9.3.3/ox-md.elc
similarity index 100%
rename from elpa/org-9.3.2/ox-md.elc
rename to elpa/org-9.3.3/ox-md.elc
diff --git a/elpa/org-9.3.2/ox-odt.el b/elpa/org-9.3.3/ox-odt.el
similarity index 99%
rename from elpa/org-9.3.2/ox-odt.el
rename to elpa/org-9.3.3/ox-odt.el
index 59480cd4..2c500e7c 100644
--- a/elpa/org-9.3.2/ox-odt.el
+++ b/elpa/org-9.3.3/ox-odt.el
@@ -940,7 +940,7 @@ See `org-odt--build-date-styles' for implementation details."
 	 (has-time-p (or (not timestamp)
 			 (org-timestamp-has-time-p timestamp)))
 	 (iso-date (let ((format (if has-time-p "%Y-%m-%dT%H:%M:%S"
-				   "%Y-%m-%dT%H:%M:%S")))
+				   "%Y-%m-%d")))
 		     (funcall format-timestamp timestamp format end))))
     (if iso-date-p iso-date
       (let* ((style (if has-time-p "OrgDate2" "OrgDate1"))
diff --git a/elpa/org-9.3.2/ox-odt.elc b/elpa/org-9.3.3/ox-odt.elc
similarity index 96%
rename from elpa/org-9.3.2/ox-odt.elc
rename to elpa/org-9.3.3/ox-odt.elc
index 7f3eebb7..98dd4904 100644
Binary files a/elpa/org-9.3.2/ox-odt.elc and b/elpa/org-9.3.3/ox-odt.elc differ
diff --git a/elpa/org-9.3.2/ox-org.el b/elpa/org-9.3.3/ox-org.el
similarity index 100%
rename from elpa/org-9.3.2/ox-org.el
rename to elpa/org-9.3.3/ox-org.el
diff --git a/elpa/org-9.3.2/ox-org.elc b/elpa/org-9.3.3/ox-org.elc
similarity index 100%
rename from elpa/org-9.3.2/ox-org.elc
rename to elpa/org-9.3.3/ox-org.elc
diff --git a/elpa/org-9.3.2/ox-publish.el b/elpa/org-9.3.3/ox-publish.el
similarity index 100%
rename from elpa/org-9.3.2/ox-publish.el
rename to elpa/org-9.3.3/ox-publish.el
diff --git a/elpa/org-9.3.2/ox-publish.elc b/elpa/org-9.3.3/ox-publish.elc
similarity index 100%
rename from elpa/org-9.3.2/ox-publish.elc
rename to elpa/org-9.3.3/ox-publish.elc
diff --git a/elpa/org-9.3.2/ox-texinfo.el b/elpa/org-9.3.3/ox-texinfo.el
similarity index 100%
rename from elpa/org-9.3.2/ox-texinfo.el
rename to elpa/org-9.3.3/ox-texinfo.el
diff --git a/elpa/org-9.3.2/ox-texinfo.elc b/elpa/org-9.3.3/ox-texinfo.elc
similarity index 100%
rename from elpa/org-9.3.2/ox-texinfo.elc
rename to elpa/org-9.3.3/ox-texinfo.elc
diff --git a/elpa/org-9.3.2/ox.el b/elpa/org-9.3.3/ox.el
similarity index 100%
rename from elpa/org-9.3.2/ox.el
rename to elpa/org-9.3.3/ox.el
diff --git a/elpa/org-9.3.2/ox.elc b/elpa/org-9.3.3/ox.elc
similarity index 100%
rename from elpa/org-9.3.2/ox.elc
rename to elpa/org-9.3.3/ox.elc
diff --git a/elpa/with-editor-20200102.2147/dir b/elpa/with-editor-20200204.1828/dir
similarity index 100%
rename from elpa/with-editor-20200102.2147/dir
rename to elpa/with-editor-20200204.1828/dir
diff --git a/elpa/with-editor-20200102.2147/with-editor-autoloads.el b/elpa/with-editor-20200204.1828/with-editor-autoloads.el
similarity index 100%
rename from elpa/with-editor-20200102.2147/with-editor-autoloads.el
rename to elpa/with-editor-20200204.1828/with-editor-autoloads.el
diff --git a/elpa/with-editor-20200102.2147/with-editor-pkg.el b/elpa/with-editor-20200204.1828/with-editor-pkg.el
similarity index 81%
rename from elpa/with-editor-20200102.2147/with-editor-pkg.el
rename to elpa/with-editor-20200204.1828/with-editor-pkg.el
index 5d16d290..b1c9642d 100644
--- a/elpa/with-editor-20200102.2147/with-editor-pkg.el
+++ b/elpa/with-editor-20200204.1828/with-editor-pkg.el
@@ -1,4 +1,4 @@
-(define-package "with-editor" "20200102.2147" "Use the Emacsclient as $EDITOR"
+(define-package "with-editor" "20200204.1828" "Use the Emacsclient as $EDITOR"
   '((emacs "24.4")
     (async "1.9"))
   :keywords
diff --git a/elpa/with-editor-20200102.2147/with-editor.el b/elpa/with-editor-20200204.1828/with-editor.el
similarity index 99%
rename from elpa/with-editor-20200102.2147/with-editor.el
rename to elpa/with-editor-20200204.1828/with-editor.el
index 76122002..4e439b70 100644
--- a/elpa/with-editor-20200102.2147/with-editor.el
+++ b/elpa/with-editor-20200204.1828/with-editor.el
@@ -176,7 +176,7 @@ please see https://github.com/magit/magit/wiki/Emacsclient."))))
 
 (defcustom with-editor-sleeping-editor "\
 sh -c '\
-echo \"WITH-EDITOR: $$ OPEN $0 IN $(pwd)\"; \
+echo -e \"WITH-EDITOR: $$ OPEN $0\\037 IN $(pwd)\"; \
 sleep 604800 & sleep=$!; \
 trap \"kill $sleep; exit 0\" USR1; \
 trap \"kill $sleep; exit 1\" USR2; \
diff --git a/elpa/with-editor-20200102.2147/with-editor.elc b/elpa/with-editor-20200204.1828/with-editor.elc
similarity index 85%
rename from elpa/with-editor-20200102.2147/with-editor.elc
rename to elpa/with-editor-20200204.1828/with-editor.elc
index 2d600de3..d2662b5c 100644
Binary files a/elpa/with-editor-20200102.2147/with-editor.elc and b/elpa/with-editor-20200204.1828/with-editor.elc differ
diff --git a/elpa/with-editor-20200102.2147/with-editor.info b/elpa/with-editor-20200204.1828/with-editor.info
similarity index 100%
rename from elpa/with-editor-20200102.2147/with-editor.info
rename to elpa/with-editor-20200204.1828/with-editor.info
diff --git a/elpa/xref-js2-20190915.2032/xref-js2-autoloads.el b/elpa/xref-js2-20190915.2032/xref-js2-autoloads.el
deleted file mode 100644
index e7a2003b..00000000
--- a/elpa/xref-js2-20190915.2032/xref-js2-autoloads.el
+++ /dev/null
@@ -1,27 +0,0 @@
-;;; xref-js2-autoloads.el --- automatically extracted autoloads
-;;
-;;; Code:
-
-(add-to-list 'load-path (directory-file-name
-                         (or (file-name-directory #$) (car load-path))))
-
-
-;;;### (autoloads nil "xref-js2" "xref-js2.el" (0 0 0 0))
-;;; Generated autoloads from xref-js2.el
-
-(autoload 'xref-js2-xref-backend "xref-js2" "\
-Xref-Js2 backend for Xref.
-
-\(fn)" nil nil)
-
-(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "xref-js2" '("xref-js2-")))
-
-;;;***
-
-;; Local Variables:
-;; version-control: never
-;; no-byte-compile: t
-;; no-update-autoloads: t
-;; coding: utf-8
-;; End:
-;;; xref-js2-autoloads.el ends here
diff --git a/elpa/xref-js2-20190915.2032/xref-js2-pkg.el b/elpa/xref-js2-20190915.2032/xref-js2-pkg.el
deleted file mode 100644
index 7e31ce17..00000000
--- a/elpa/xref-js2-20190915.2032/xref-js2-pkg.el
+++ /dev/null
@@ -1,2 +0,0 @@
-;;; -*- no-byte-compile: t -*-
-(define-package "xref-js2" "20190915.2032" "Jump to references/definitions using ag & js2-mode's AST" '((emacs "25") (js2-mode "20150909")) :commit "6f1ed5dae0c2485416196a51f2fa92f32e4b8262" :keywords '("javascript" "convenience" "tools") :authors '(("Nicolas Petton" . "nicolas@petton.fr")) :maintainer '("Nicolas Petton" . "nicolas@petton.fr") :url "https://github.com/NicolasPetton/xref-js2")
diff --git a/elpa/xref-js2-20190915.2032/xref-js2.el b/elpa/xref-js2-20190915.2032/xref-js2.el
deleted file mode 100644
index edc0b9ce..00000000
--- a/elpa/xref-js2-20190915.2032/xref-js2.el
+++ /dev/null
@@ -1,273 +0,0 @@
-;;; xref-js2.el --- Jump to references/definitions using ag & js2-mode's AST -*- lexical-binding: t; -*-
-
-;; Copyright (C) 2016 Nicolas Petton
-
-;; Author: Nicolas Petton <nicolas@petton.fr>
-;; URL: https://github.com/NicolasPetton/xref-js2
-;; Package-Version: 20190915.2032
-;; Keywords: javascript, convenience, tools
-;; Version: 1.0
-;; Package: xref-js2
-;; Package-Requires: ((emacs "25") (js2-mode "20150909"))
-
-;; 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:
-;;
-;; xref-js2 adds an xref backend for JavaScript files.
-;;
-;; Instead of using a tag system, it relies on `ag' to query the codebase of a
-;; project.  This might sound crazy at first, but it turns out that `ag' is so
-;; fast that jumping using xref-js2 is most of the time instantaneous, even on
-;; fairly large JavaScript codebase (it successfully works with 50k lines of JS
-;; code).
-;;
-;; Because line by line regexp search has its downside, xref-js2 does a second
-;; pass on result candidates and eliminates possible false positives using
-;; `js2-mode''s AST, thus giving very accurate results.
-
-;;; Code:
-
-(require 'subr-x)
-(require 'xref)
-(require 'seq)
-(require 'map)
-(require 'js2-mode)
-(require 'vc)
-
-(defcustom xref-js2-search-program 'ag
-  "The backend program used for searching."
-  :type 'symbol
-  :group 'xref-js2
-  :options '(ag rg))
-
-(defcustom xref-js2-ag-arguments '("--js" "--noheading" "--nocolor")
-  "Default arguments passed to ag."
-  :type 'list
-  :group 'xref-js2)
-
-(defcustom xref-js2-js-extensions '("js" "mjs" "jsx" "ts" "tsx")
-  "Extensions for file types xref-js2 is expected to search.
-warning, this is currently only supported by ripgrep, not ag.
-
-if an empty-list/nil no filtering based on file extension will
-take place."
-  :type 'list
-  :group 'xref-js2)
-
-(defcustom xref-js2-rg-arguments '("--no-heading"
-                                   "--line-number"    ; not activated by default on comint
-                                   "--pcre2"          ; provides regexp backtracking
-                                   "--ignore-case"    ; ag is case insensitive by default
-                                   "--color" "never")
-  "Default arguments passed to ripgrep."
-  :type 'list
-  :group 'xref-js2)
-
-(defcustom xref-js2-ignored-dirs '("bower_components"
-                                   "node_modules"
-                                   "build"
-                                   "lib")
-  "List of directories to be ignored when performing a search."
-  :type 'list
-  :group 'xref-js2)
-
-(defcustom xref-js2-ignored-files '("*.min.js")
-  "List of files to be ignored when performing a search."
-  :type 'list
-  :group 'xref-js2)
-
-(defcustom xref-js2-definitions-regexps '("\\b%s\\b[\\s]*[:=][^=]"
-                                          "function[\\s]+\\b%s\\b"
-                                          "class[\\s]+\\b%s\\b"
-                                          "(?<!new)[^.]%s[\\s]*\\(")
-  "List of regular expressions that match definitions of a symbol.
-In each regexp string, '%s' is expanded with the searched symbol."
-  :type 'list
-  :group 'xref-js2)
-
-(defcustom xref-js2-references-regexps '("\\b%s\\b(?!\\s*[:=][^=])")
-  "List of regular expressions that match references to a symbol.
-In each regexp string, '%s' is expanded with the searched symbol."
-  :type 'list
-  :group 'xref-js2)
-
-;;;###autoload
-(defun xref-js2-xref-backend ()
-  "Xref-Js2 backend for Xref."
-  'xref-js2)
-
-(cl-defmethod xref-backend-identifier-at-point ((_backend (eql xref-js2)))
-  (symbol-name (symbol-at-point)))
-
-(cl-defmethod xref-backend-definitions ((_backend (eql xref-js2)) symbol)
-  (xref-js2--xref-find-definitions symbol))
-
-(cl-defmethod xref-backend-references ((_backend (eql xref-js2)) symbol)
-  (xref-js2--xref-find-references symbol))
-
-(defun xref-js2--xref-find-definitions (symbol)
-  "Return a list of candidates matching SYMBOL."
-  (seq-map (lambda (candidate)
-             (xref-js2--make-xref candidate))
-           (xref-js2--find-definitions symbol)))
-
-(cl-defmethod xref-backend-identifier-completion-table ((_backend (eql xref-js2)))
-  "Return a list of terms for completions taken from the symbols in the current buffer.
-
-The current implementation returns all the words in the buffer,
-which is really sub optimal."
-  (let (words)
-    (save-excursion
-      (save-restriction
-        (widen)
-        (goto-char (point-min))
-        (while (re-search-forward "\\w+" nil t)
-          (add-to-list 'words (match-string-no-properties 0)))
-        (seq-uniq words)))))
-
-(defun xref-js2--xref-find-references (symbol)
-  "Return a list of reference candidates matching SYMBOL."
-  (seq-map (lambda (candidate)
-             (xref-js2--make-xref candidate))
-           (xref-js2--find-references symbol)))
-
-(defun xref-js2--make-xref (candidate)
-  "Return a new Xref object built from CANDIDATE."
-  (xref-make (map-elt candidate 'match)
-             (xref-make-file-location (map-elt candidate 'file)
-                                      (map-elt candidate 'line)
-                                      0)))
-
-(defun xref-js2--find-definitions (symbol)
-  "Return a list of definitions for SYMBOL from an ag search."
-  (xref-js2--find-candidates
-   symbol
-   (xref-js2--make-regexp symbol xref-js2-definitions-regexps)))
-
-(defun xref-js2--find-references (symbol)
-  "Return a list of references for SYMBOL from an ag search."
-  (xref-js2--find-candidates
-   symbol
-   (xref-js2--make-regexp symbol xref-js2-references-regexps)))
-
-(defun xref-js2--make-regexp (symbol regexps)
-  "Return a regular expression to search for SYMBOL using REGEXPS.
-
-REGEXPS must be a list of regular expressions, which are
-concatenated together into one regexp, expanding occurrences of
-'%s' with SYMBOL."
-  (mapconcat #'identity
-             (mapcar (lambda (str)
-                       (format str symbol))
-                     regexps) "|"))
-
-(defun xref-js2--find-candidates (symbol regexp)
-  (let ((default-directory (xref-js2--root-dir))
-        matches)
-    (with-temp-buffer
-      (let* ((search-tuple (cond ;; => (prog-name . function-to-get-args)
-                            ((eq xref-js2-search-program 'rg)
-                             '("rg" . xref-js2--search-rg-get-args))
-                            (t ;; (eq xref-js2-search-program 'ag)
-                             '("ag" . xref-js2--search-ag-get-args))))
-             (search-program (car search-tuple))
-             (search-args    (remove nil ;; rm in case no search args given
-                                     (funcall (cdr search-tuple) regexp))))
-        (apply #'process-file (executable-find search-program) nil t nil search-args))
-
-      (goto-char (point-max)) ;; NOTE maybe redundant
-      (while (re-search-backward "^\\(.+\\)$" nil t)
-        (push (match-string-no-properties 1) matches)))
-    (seq-remove #'xref-js2--false-positive
-                (seq-map (lambda (match)
-                           (xref-js2--candidate symbol match))
-                         matches))))
-
-(defun xref-js2--search-ag-get-args (regexp)
-  "Aggregate command line arguments to search for REGEXP using ag."
-  `(,@xref-js2-ag-arguments
-    ,@(seq-mapcat (lambda (dir)
-                    (list "--ignore-dir" dir))
-                  xref-js2-ignored-dirs)
-    ,@(seq-mapcat (lambda (file)
-                    (list "--ignore" file))
-                  xref-js2-ignored-files)
-    ,regexp))
-
-(defun xref-js2--search-rg-get-args (regexp)
-  "Aggregate command line arguments to search for REGEXP using ripgrep."
-  `(,@xref-js2-rg-arguments
-    ,@(if (not xref-js2-js-extensions)
-          nil ;; no filtering based on extension
-        (seq-mapcat (lambda (ext)
-                      (list "-g" (concat "*." ext)))
-                    xref-js2-js-extensions))
-    ,@(seq-mapcat (lambda (dir)
-                    (list "-g" (concat "!"                               ; exclude not include
-                                       dir                               ; directory string
-                                       (unless (string-suffix-p "/" dir) ; pattern for a directory
-                                         "/"))))                         ; must end with a slash
-                  xref-js2-ignored-dirs)
-    ,@(seq-mapcat (lambda (pattern)
-                    (list "-g" (concat "!" pattern)))
-                  xref-js2-ignored-files)
-    ,regexp))
-
-(defun xref-js2--false-positive (candidate)
-  "Return non-nil if CANDIDATE is a false positive.
-Filtering is done using the AST from js2-mode."
-  (let* ((file (map-elt candidate 'file))
-         (buffer-open (get-file-buffer file)))
-    (prog1
-        (with-current-buffer (find-file-noselect file t)
-          (save-excursion
-            (save-restriction
-              (widen)
-              (unless (or (eq major-mode 'js2-mode)
-                          (seq-contains (map-keys minor-mode-alist) 'js2-minor-mode))
-                (js2-minor-mode 1))
-              (goto-char (point-min))
-              (forward-line (1- (map-elt candidate 'line)))
-              (search-forward (map-elt candidate 'symbol) nil t)
-              ;; js2-mode fails to parse the AST for some minified files
-              (ignore-errors
-                (let ((node (js2-node-at-point)))
-                  (or (js2-string-node-p node)
-                      (js2-comment-node-p node))))))))))
-
-(defun xref-js2--root-dir ()
-  "Return the root directory of the project."
-  (or (ignore-errors
-        (projectile-project-root))
-      (ignore-errors
-        (vc-root-dir))
-      (user-error "You are not in a project")))
-
-(defun xref-js2--candidate (symbol match)
-  "Return a candidate alist built from SYMBOL and a raw MATCH result.
-The MATCH is one output result from the ag search."
-  (let* ((attrs (split-string match ":" t))
-         (match (string-trim (mapconcat #'identity (cddr attrs) ":"))))
-    ;; Some minified JS files might match a search. To avoid cluttering the
-    ;; search result, we trim the output.
-    (when (> (seq-length match) 100)
-      (setq match (concat (seq-take match 100) "...")))
-    (list (cons 'file (expand-file-name (car attrs) (xref-js2--root-dir)))
-          (cons 'line (string-to-number (cadr attrs)))
-          (cons 'symbol symbol)
-          (cons 'match match))))
-
-(provide 'xref-js2)
-;;; xref-js2.el ends here
diff --git a/elpa/xref-js2-20190915.2032/xref-js2.elc b/elpa/xref-js2-20190915.2032/xref-js2.elc
deleted file mode 100644
index 1a07e74f..00000000
Binary files a/elpa/xref-js2-20190915.2032/xref-js2.elc and /dev/null differ