Update packages/ Add org-ref

elpa/archives/gnu/archive-contents

@@ -375,7 +375,7 @@
 	     ((:url . "http://elpa.gnu.org/packages/ediprolog.html")
 	      (:keywords "languages" "processes"))])
  (eglot .
-	[(0 8)
+	[(0 9)
 	 ((emacs
 	   (26 1)))
 	 "Client for Language Server Protocol (LSP) servers" tar
@@ -497,7 +497,7 @@
 		 ((:keywords "gnome" "c" "coding style")
 		  (:url . "http://elpa.gnu.org/packages/gnome-c-style.html"))])
  (gnorb .
-	[(1 5 4)
+	[(1 5 5)
 	 ((cl-lib
 	   (0 5)))
 	 "Glue code between Gnus, Org, and BBDB" tar

elpa/archives/gnu/archive-contents.signed

@@ -1 +1 @@
-Good signature from 474F05837FBDEF9B GNU ELPA Signing Agent <elpasign@elpa.gnu.org> (trust undefined) created at 2018-06-04T06:10:04-0300 using DSA
+Good signature from 474F05837FBDEF9B GNU ELPA Signing Agent <elpasign@elpa.gnu.org> (trust undefined) created at 2018-06-11T06:10:02-0300 using DSA

elpa/async-20180527.1030/async-autoloads.el

@@ -0,0 +1,174 @@
+;;; async-autoloads.el --- automatically extracted autoloads
+;;
+;;; Code:
+
+(add-to-list 'load-path (directory-file-name
+                         (or (file-name-directory #$) (car load-path))))
+
+
+;;;### (autoloads nil "async" "async.el" (0 0 0 0))
+;;; Generated autoloads from async.el
+
+(autoload 'async-start-process "async" "\
+Start the executable PROGRAM asynchronously.  See `async-start'.
+PROGRAM is passed PROGRAM-ARGS, calling FINISH-FUNC with the
+process object when done.  If FINISH-FUNC is nil, the future
+object will return the process object when the program is
+finished.  Set DEFAULT-DIRECTORY to change PROGRAM's current
+working directory.
+
+\(fn NAME PROGRAM FINISH-FUNC &rest PROGRAM-ARGS)" nil nil)
+
+(autoload 'async-start "async" "\
+Execute START-FUNC (often a lambda) in a subordinate Emacs process.
+When done, the return value is passed to FINISH-FUNC.  Example:
+
+    (async-start
+       ;; What to do in the child process
+       (lambda ()
+         (message \"This is a test\")
+         (sleep-for 3)
+         222)
+
+       ;; What to do when it finishes
+       (lambda (result)
+         (message \"Async process done, result should be 222: %s\"
+                  result)))
+
+If FINISH-FUNC is nil or missing, a future is returned that can
+be inspected using `async-get', blocking until the value is
+ready.  Example:
+
+    (let ((proc (async-start
+                   ;; What to do in the child process
+                   (lambda ()
+                     (message \"This is a test\")
+                     (sleep-for 3)
+                     222))))
+
+        (message \"I'm going to do some work here\") ;; ....
+
+        (message \"Waiting on async process, result should be 222: %s\"
+                 (async-get proc)))
+
+If you don't want to use a callback, and you don't care about any
+return value from the child process, pass the `ignore' symbol as
+the second argument (if you don't, and never call `async-get', it
+will leave *emacs* process buffers hanging around):
+
+    (async-start
+     (lambda ()
+       (delete-file \"a remote file on a slow link\" nil))
+     'ignore)
+
+Note: Even when FINISH-FUNC is present, a future is still
+returned except that it yields no value (since the value is
+passed to FINISH-FUNC).  Call `async-get' on such a future always
+returns nil.  It can still be useful, however, as an argument to
+`async-ready' or `async-wait'.
+
+\(fn START-FUNC &optional FINISH-FUNC)" nil nil)
+
+(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "async" '("async-")))
+
+;;;***
+
+;;;### (autoloads nil "async-bytecomp" "async-bytecomp.el" (0 0 0
+;;;;;;  0))
+;;; Generated autoloads from async-bytecomp.el
+
+(autoload 'async-byte-recompile-directory "async-bytecomp" "\
+Compile all *.el files in DIRECTORY asynchronously.
+All *.elc files are systematically deleted before proceeding.
+
+\(fn DIRECTORY &optional QUIET)" nil nil)
+
+(defvar async-bytecomp-package-mode nil "\
+Non-nil if Async-Bytecomp-Package mode is enabled.
+See the `async-bytecomp-package-mode' command
+for a description of this minor mode.
+Setting this variable directly does not take effect;
+either customize it (see the info node `Easy Customization')
+or call the function `async-bytecomp-package-mode'.")
+
+(custom-autoload 'async-bytecomp-package-mode "async-bytecomp" nil)
+
+(autoload 'async-bytecomp-package-mode "async-bytecomp" "\
+Byte compile asynchronously packages installed with package.el.
+Async compilation of packages can be controlled by
+`async-bytecomp-allowed-packages'.
+
+\(fn &optional ARG)" t nil)
+
+(autoload 'async-byte-compile-file "async-bytecomp" "\
+Byte compile Lisp code FILE asynchronously.
+
+Same as `byte-compile-file' but asynchronous.
+
+\(fn FILE)" t nil)
+
+(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "async-bytecomp" '("async-byte")))
+
+;;;***
+
+;;;### (autoloads nil "dired-async" "dired-async.el" (0 0 0 0))
+;;; Generated autoloads from dired-async.el
+
+(defvar dired-async-mode nil "\
+Non-nil if Dired-Async mode is enabled.
+See the `dired-async-mode' command
+for a description of this minor mode.
+Setting this variable directly does not take effect;
+either customize it (see the info node `Easy Customization')
+or call the function `dired-async-mode'.")
+
+(custom-autoload 'dired-async-mode "dired-async" nil)
+
+(autoload 'dired-async-mode "dired-async" "\
+Do dired actions asynchronously.
+
+\(fn &optional ARG)" t nil)
+
+(autoload 'dired-async-do-copy "dired-async" "\
+Run ‘dired-do-copy’ asynchronously.
+
+\(fn &optional ARG)" t nil)
+
+(autoload 'dired-async-do-symlink "dired-async" "\
+Run ‘dired-do-symlink’ asynchronously.
+
+\(fn &optional ARG)" t nil)
+
+(autoload 'dired-async-do-hardlink "dired-async" "\
+Run ‘dired-do-hardlink’ asynchronously.
+
+\(fn &optional ARG)" t nil)
+
+(autoload 'dired-async-do-rename "dired-async" "\
+Run ‘dired-do-rename’ asynchronously.
+
+\(fn &optional ARG)" t nil)
+
+(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "dired-async" '("dired-async-")))
+
+;;;***
+
+;;;### (autoloads nil "smtpmail-async" "smtpmail-async.el" (0 0 0
+;;;;;;  0))
+;;; Generated autoloads from smtpmail-async.el
+
+(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "smtpmail-async" '("async-smtpmail-")))
+
+;;;***
+
+;;;### (autoloads nil nil ("async-pkg.el") (0 0 0 0))
+
+;;;***
+
+;; Local Variables:
+;; version-control: never
+;; no-byte-compile: t
+;; no-update-autoloads: t
+;; coding: utf-8
+;; End:
+;;; async-autoloads.el ends here

elpa/async-20180527.1030/async-bytecomp.el

@@ -0,0 +1,219 @@
+;;; async-bytecomp.el --- Compile elisp files asynchronously -*- lexical-binding: t -*-
+
+;; Copyright (C) 2014-2016 Free Software Foundation, Inc.
+
+;; Authors: John Wiegley <jwiegley@gmail.com>
+;;          Thierry Volpiatto <thierry.volpiatto@gmail.com>
+
+;; Keywords: dired async byte-compile
+;; X-URL: https://github.com/jwiegley/dired-async
+
+;; 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 2, 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 GNU Emacs; see the file COPYING.  If not, write to the
+;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
+
+;;; Commentary:
+;;
+;;  This package provide the `async-byte-recompile-directory' function
+;;  which allows, as the name says to recompile a directory outside of
+;;  your running emacs.
+;;  The benefit is your files will be compiled in a clean environment without
+;;  the old *.el files loaded.
+;;  Among other things, this fix a bug in package.el which recompile
+;;  the new files in the current environment with the old files loaded, creating
+;;  errors in most packages after upgrades.
+;;
+;;  NB: This package is advicing the function `package--compile'.
+
+;;; Code:
+
+(require 'cl-lib)
+(require 'async)
+
+(defcustom async-bytecomp-allowed-packages
+  '(async helm helm-core helm-ls-git helm-ls-hg magit)
+  "Packages in this list will be compiled asynchronously by `package--compile'.
+All the dependencies of these packages will be compiled async too,
+so no need to add dependencies to this list.
+The value of this variable can also be a list with a single element,
+the symbol `all', in this case packages are always compiled asynchronously."
+  :group 'async
+  :type '(repeat (choice symbol)))
+
+(defvar async-byte-compile-log-file
+  (concat user-emacs-directory "async-bytecomp.log"))
+
+;;;###autoload
+(defun async-byte-recompile-directory (directory &optional quiet)
+  "Compile all *.el files in DIRECTORY asynchronously.
+All *.elc files are systematically deleted before proceeding."
+  (cl-loop with dir = (directory-files directory t "\\.elc\\'")
+           unless dir return nil
+           for f in dir
+           when (file-exists-p f) do (delete-file f))
+  ;; Ensure async is reloaded when async.elc is deleted.
+  ;; This happen when recompiling its own directory.
+  (load "async")
+  (let ((call-back
+         (lambda (&optional _ignore)
+           (if (file-exists-p async-byte-compile-log-file)
+               (let ((buf (get-buffer-create byte-compile-log-buffer))
+                     (n 0))
+                 (with-current-buffer buf
+                   (goto-char (point-max))
+                   (let ((inhibit-read-only t))
+                     (insert-file-contents async-byte-compile-log-file)
+                     (compilation-mode))
+                   (display-buffer buf)
+                   (delete-file async-byte-compile-log-file)
+                   (unless quiet
+                     (save-excursion
+                       (goto-char (point-min))
+                       (while (re-search-forward "^.*:Error:" nil t)
+                         (cl-incf n)))
+                     (if (> n 0)
+                         (message "Failed to compile %d files in directory `%s'" n directory)
+                         (message "Directory `%s' compiled asynchronously with warnings" directory)))))
+               (unless quiet
+                 (message "Directory `%s' compiled asynchronously with success" directory))))))
+    (async-start
+     `(lambda ()
+        (require 'bytecomp)
+        ,(async-inject-variables "\\`\\(load-path\\)\\|byte\\'")
+        (let ((default-directory (file-name-as-directory ,directory))
+              error-data)
+          (add-to-list 'load-path default-directory)
+          (byte-recompile-directory ,directory 0 t)
+          (when (get-buffer byte-compile-log-buffer)
+            (setq error-data (with-current-buffer byte-compile-log-buffer
+                               (buffer-substring-no-properties (point-min) (point-max))))
+            (unless (string= error-data "")
+              (with-temp-file ,async-byte-compile-log-file
+                (erase-buffer)
+                (insert error-data))))))
+     call-back)
+    (unless quiet (message "Started compiling asynchronously directory %s" directory))))
+
+(defvar package-archive-contents)
+(defvar package-alist)
+(declare-function package-desc-reqs "package.el" (cl-x))
+
+(defun async-bytecomp--get-package-deps (pkg &optional only)
+  ;; Same as `package--get-deps' but parse instead `package-archive-contents'
+  ;; because PKG is not already installed and not present in `package-alist'.
+  ;; However fallback to `package-alist' in case PKG no more present
+  ;; in `package-archive-contents' due to modification to `package-archives'.
+  ;; See issue #58.
+  (let* ((pkg-desc (cadr (or (assq pkg package-archive-contents)
+                             (assq pkg package-alist))))
+         (direct-deps (cl-loop for p in (package-desc-reqs pkg-desc)
+                               for name = (car p)
+                               when (or (assq name package-archive-contents)
+                                        (assq name package-alist))
+                               collect name))
+         (indirect-deps (unless (eq only 'direct)
+                          (delete-dups
+                           (cl-loop for p in direct-deps append
+                                    (async-bytecomp--get-package-deps p))))))
+    (cl-case only
+      (direct   direct-deps)
+      (separate (list direct-deps indirect-deps))
+      (indirect indirect-deps)
+      (t        (delete-dups (append direct-deps indirect-deps))))))
+
+(defun async-bytecomp-get-allowed-pkgs ()
+  (when (and async-bytecomp-allowed-packages
+             (listp async-bytecomp-allowed-packages))
+    (if package-archive-contents
+        (cl-loop for p in async-bytecomp-allowed-packages
+                 when (assq p package-archive-contents)
+                 append (async-bytecomp--get-package-deps p) into reqs
+                 finally return
+                 (delete-dups
+                  (append async-bytecomp-allowed-packages reqs)))
+        async-bytecomp-allowed-packages)))
+
+(defadvice package--compile (around byte-compile-async)
+  (let ((cur-package (package-desc-name pkg-desc))
+        (pkg-dir (package-desc-dir pkg-desc)))
+    (if (or (equal async-bytecomp-allowed-packages '(all))
+            (memq cur-package (async-bytecomp-get-allowed-pkgs)))
+        (progn
+          (when (eq cur-package 'async)
+            (fmakunbound 'async-byte-recompile-directory))
+          ;; Add to `load-path' the latest version of async and
+          ;; reload it when reinstalling async.
+          (when (string= cur-package "async")
+            (cl-pushnew pkg-dir load-path)
+            (load "async-bytecomp"))
+          ;; `async-byte-recompile-directory' will add directory
+          ;; as needed to `load-path'.
+          (async-byte-recompile-directory (package-desc-dir pkg-desc) t))
+        ad-do-it)))
+
+;;;###autoload
+(define-minor-mode async-bytecomp-package-mode
+    "Byte compile asynchronously packages installed with package.el.
+Async compilation of packages can be controlled by
+`async-bytecomp-allowed-packages'."
+  :group 'async
+  :global t
+  (if async-bytecomp-package-mode
+      (ad-activate 'package--compile)
+      (ad-deactivate 'package--compile)))
+
+;;;###autoload
+(defun async-byte-compile-file (file)
+  "Byte compile Lisp code FILE asynchronously.
+
+Same as `byte-compile-file' but asynchronous."
+  (interactive "fFile: ")
+  (let ((call-back
+         (lambda (&optional _ignore)
+           (let ((bn (file-name-nondirectory file)))
+             (if (file-exists-p async-byte-compile-log-file)
+                 (let ((buf (get-buffer-create byte-compile-log-buffer))
+                       start)
+                   (with-current-buffer buf
+                     (goto-char (setq start (point-max)))
+                     (let ((inhibit-read-only t))
+                       (insert-file-contents async-byte-compile-log-file)
+                       (compilation-mode))
+                     (display-buffer buf)
+                     (delete-file async-byte-compile-log-file)
+                     (save-excursion
+                       (goto-char start)
+                       (if (re-search-forward "^.*:Error:" nil t)
+                           (message "Failed to compile `%s'" bn)
+                         (message "`%s' compiled asynchronously with warnings" bn)))))
+               (message "`%s' compiled asynchronously with success" bn))))))
+    (async-start
+     `(lambda ()
+        (require 'bytecomp)
+        ,(async-inject-variables "\\`load-path\\'")
+        (let ((default-directory ,(file-name-directory file)))
+          (add-to-list 'load-path default-directory)
+          (byte-compile-file ,file)
+          (when (get-buffer byte-compile-log-buffer)
+            (setq error-data (with-current-buffer byte-compile-log-buffer
+                               (buffer-substring-no-properties (point-min) (point-max))))
+            (unless (string= error-data "")
+              (with-temp-file ,async-byte-compile-log-file
+                (erase-buffer)
+                (insert error-data))))))
+     call-back)))
+
+(provide 'async-bytecomp)
+
+;;; async-bytecomp.el ends here

elpa/async-20180527.1030/async-pkg.el

@@ -0,0 +1,6 @@
+(define-package "async" "20180527.1030" "Asynchronous processing in Emacs" 'nil :keywords
+  '("async")
+  :url "https://github.com/jwiegley/emacs-async")
+;; Local Variables:
+;; no-byte-compile: t
+;; End:

elpa/async-20180527.1030/async.el

@@ -0,0 +1,392 @@
+;;; async.el --- Asynchronous processing in Emacs -*- lexical-binding: t -*-
+
+;; Copyright (C) 2012-2016 Free Software Foundation, Inc.
+
+;; Author: John Wiegley <jwiegley@gmail.com>
+;; Created: 18 Jun 2012
+;; Version: 1.9.3
+
+;; Keywords: async
+;; X-URL: https://github.com/jwiegley/emacs-async
+
+;; 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 2, 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 GNU Emacs; see the file COPYING.  If not, write to the
+;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
+
+;;; Commentary:
+
+;; Adds the ability to call asynchronous functions and process with ease.  See
+;; the documentation for `async-start' and `async-start-process'.
+
+;;; Code:
+
+(eval-when-compile (require 'cl-lib))
+
+(defgroup async nil
+  "Simple asynchronous processing in Emacs"
+  :group 'emacs)
+
+(defcustom async-variables-noprops-function #'async-variables-noprops
+  "Default function to remove text properties in variables."
+  :group 'async
+  :type 'function)
+
+(defvar async-debug nil)
+(defvar async-send-over-pipe t)
+(defvar async-in-child-emacs nil)
+(defvar async-callback nil)
+(defvar async-callback-for-process nil)
+(defvar async-callback-value nil)
+(defvar async-callback-value-set nil)
+(defvar async-current-process nil)
+(defvar async--procvar nil)
+
+(defun async-variables-noprops (sequence)
+  "Remove text properties in SEQUENCE.
+
+Argument SEQUENCE may be a list or a string, if anything else it
+is returned unmodified.
+
+Note that this is a naive function that doesn't remove text properties
+in SEQUENCE recursively, only at the first level which suffice in most
+cases."
+  (cond ((stringp sequence)
+         (substring-no-properties sequence))
+        ((listp sequence)
+         (cl-loop for elm in sequence
+                  if (stringp elm)
+                  collect (substring-no-properties elm)
+                  else collect elm))
+        (t sequence)))
+
+(defun async-inject-variables
+  (include-regexp &optional predicate exclude-regexp noprops)
+  "Return a `setq' form that replicates part of the calling environment.
+
+It sets the value for every variable matching INCLUDE-REGEXP and
+also PREDICATE.  It will not perform injection for any variable
+matching EXCLUDE-REGEXP (if present) or representing a syntax-table
+i.e. ending by \"-syntax-table\".
+When NOPROPS is non nil it tries to strip out text properties of each
+variable's value with `async-variables-noprops-function'.
+
+It is intended to be used as follows:
+
+    (async-start
+       `(lambda ()
+          (require 'smtpmail)
+          (with-temp-buffer
+            (insert ,(buffer-substring-no-properties (point-min) (point-max)))
+            ;; Pass in the variable environment for smtpmail
+            ,(async-inject-variables \"\\`\\(smtpmail\\|\\(user-\\)?mail\\)-\")
+            (smtpmail-send-it)))
+       'ignore)"
+  `(setq
+    ,@(let (bindings)
+        (mapatoms
+         (lambda (sym)
+           (let* ((sname (and (boundp sym) (symbol-name sym)))
+                  (value (and sname (symbol-value sym))))
+             (when (and sname
+                        (or (null include-regexp)
+                            (string-match include-regexp sname))
+                        (or (null exclude-regexp)
+                            (not (string-match exclude-regexp sname)))
+                        (not (string-match "-syntax-table\\'" sname)))
+               (unless (or (stringp value)
+                           (memq value '(nil t))
+                           (numberp value)
+                           (vectorp value))
+                 (setq value `(quote ,value)))
+               (when noprops
+                 (setq value (funcall async-variables-noprops-function
+                                      value)))
+               (when (or (null predicate)
+                         (funcall predicate sym))
+                 (setq bindings (cons value bindings)
+                       bindings (cons sym bindings)))))))
+        bindings)))
+
+(defalias 'async-inject-environment 'async-inject-variables)
+
+(defun async-handle-result (func result buf)
+  (if (null func)
+      (progn
+        (set (make-local-variable 'async-callback-value) result)
+        (set (make-local-variable 'async-callback-value-set) t))
+    (unwind-protect
+        (if (and (listp result)
+                 (eq 'async-signal (nth 0 result)))
+            (signal (car (nth 1 result))
+                    (cdr (nth 1 result)))
+          (funcall func result))
+      (unless async-debug
+        (kill-buffer buf)))))
+
+(defun async-when-done (proc &optional _change)
+  "Process sentinel used to retrieve the value from the child process."
+  (when (eq 'exit (process-status proc))
+    (with-current-buffer (process-buffer proc)
+      (let ((async-current-process proc))
+        (if (= 0 (process-exit-status proc))
+            (if async-callback-for-process
+                (if async-callback
+                    (prog1
+                        (funcall async-callback proc)
+                      (unless async-debug
+                        (kill-buffer (current-buffer))))
+                  (set (make-local-variable 'async-callback-value) proc)
+                  (set (make-local-variable 'async-callback-value-set) t))
+              (goto-char (point-max))
+              (backward-sexp)
+              (async-handle-result async-callback (read (current-buffer))
+                                   (current-buffer)))
+          (set (make-local-variable 'async-callback-value)
+               (list 'error
+                     (format "Async process '%s' failed with exit code %d"
+                             (process-name proc) (process-exit-status proc))))
+          (set (make-local-variable 'async-callback-value-set) t))))))
+
+(defun async--receive-sexp (&optional stream)
+  (let ((sexp (decode-coding-string (base64-decode-string
+                                     (read stream)) 'utf-8-auto))
+	;; Parent expects UTF-8 encoded text.
+	(coding-system-for-write 'utf-8-auto))
+    (if async-debug
+        (message "Received sexp {{{%s}}}" (pp-to-string sexp)))
+    (setq sexp (read sexp))
+    (if async-debug
+        (message "Read sexp {{{%s}}}" (pp-to-string sexp)))
+    (eval sexp)))
+
+(defun async--insert-sexp (sexp)
+  (let (print-level
+	print-length
+	(print-escape-nonascii t)
+	(print-circle t))
+    (prin1 sexp (current-buffer))
+    ;; Just in case the string we're sending might contain EOF
+    (encode-coding-region (point-min) (point-max) 'utf-8-auto)
+    (base64-encode-region (point-min) (point-max) t)
+    (goto-char (point-min)) (insert ?\")
+    (goto-char (point-max)) (insert ?\" ?\n)))
+
+(defun async--transmit-sexp (process sexp)
+  (with-temp-buffer
+    (if async-debug
+        (message "Transmitting sexp {{{%s}}}" (pp-to-string sexp)))
+    (async--insert-sexp sexp)
+    (process-send-region process (point-min) (point-max))))
+
+(defun async-batch-invoke ()
+  "Called from the child Emacs process' command-line."
+  ;; Make sure 'message' and 'prin1' encode stuff in UTF-8, as parent
+  ;; process expects.
+  (let ((coding-system-for-write 'utf-8-auto))
+    (setq async-in-child-emacs t
+	  debug-on-error async-debug)
+    (if debug-on-error
+	(prin1 (funcall
+		(async--receive-sexp (unless async-send-over-pipe
+				       command-line-args-left))))
+      (condition-case err
+	  (prin1 (funcall
+		  (async--receive-sexp (unless async-send-over-pipe
+					 command-line-args-left))))
+	(error
+	 (prin1 (list 'async-signal err)))))))
+
+(defun async-ready (future)
+  "Query a FUTURE to see if it is ready.
+
+I.e., if no blocking
+would result from a call to `async-get' on that FUTURE."
+  (and (memq (process-status future) '(exit signal))
+       (let ((buf (process-buffer future)))
+         (if (buffer-live-p buf)
+             (with-current-buffer buf
+               async-callback-value-set)
+             t))))
+
+(defun async-wait (future)
+  "Wait for FUTURE to become ready."
+  (while (not (async-ready future))
+    (sleep-for 0.05)))
+
+(defun async-get (future)
+  "Get the value from process FUTURE when it is ready.
+FUTURE is returned by `async-start' or `async-start-process' when
+its FINISH-FUNC is nil."
+  (and future (async-wait future))
+  (let ((buf (process-buffer future)))
+    (when (buffer-live-p buf)
+      (with-current-buffer buf
+        (async-handle-result
+         #'identity async-callback-value (current-buffer))))))
+
+(defun async-message-p (value)
+  "Return true of VALUE is an async.el message packet."
+  (and (listp value)
+       (plist-get value :async-message)))
+
+(defun async-send (&rest args)
+  "Send the given messages to the asychronous Emacs PROCESS."
+  (let ((args (append args '(:async-message t))))
+    (if async-in-child-emacs
+        (if async-callback
+            (funcall async-callback args))
+      (async--transmit-sexp (car args) (list 'quote (cdr args))))))
+
+(defun async-receive ()
+  "Send the given messages to the asychronous Emacs PROCESS."
+  (async--receive-sexp))
+
+;;;###autoload
+(defun async-start-process (name program finish-func &rest program-args)
+  "Start the executable PROGRAM asynchronously.  See `async-start'.
+PROGRAM is passed PROGRAM-ARGS, calling FINISH-FUNC with the
+process object when done.  If FINISH-FUNC is nil, the future
+object will return the process object when the program is
+finished.  Set DEFAULT-DIRECTORY to change PROGRAM's current
+working directory."
+  (let* ((buf (generate-new-buffer (concat "*" name "*")))
+         (proc (let ((process-connection-type nil))
+                 (apply #'start-process name buf program program-args))))
+    (with-current-buffer buf
+      (set (make-local-variable 'async-callback) finish-func)
+      (set-process-sentinel proc #'async-when-done)
+      (unless (string= name "emacs")
+        (set (make-local-variable 'async-callback-for-process) t))
+      proc)))
+
+(defvar async-quiet-switch "-Q"
+  "The Emacs parameter to use to call emacs without config.
+Can be one of \"-Q\" or \"-q\".
+Default is \"-Q\" but it is sometimes useful to use \"-q\" to have a
+enhanced config or some more variables loaded.")
+
+;;;###autoload
+(defun async-start (start-func &optional finish-func)
+  "Execute START-FUNC (often a lambda) in a subordinate Emacs process.
+When done, the return value is passed to FINISH-FUNC.  Example:
+
+    (async-start
+       ;; What to do in the child process
+       (lambda ()
+         (message \"This is a test\")
+         (sleep-for 3)
+         222)
+
+       ;; What to do when it finishes
+       (lambda (result)
+         (message \"Async process done, result should be 222: %s\"
+                  result)))
+
+If FINISH-FUNC is nil or missing, a future is returned that can
+be inspected using `async-get', blocking until the value is
+ready.  Example:
+
+    (let ((proc (async-start
+                   ;; What to do in the child process
+                   (lambda ()
+                     (message \"This is a test\")
+                     (sleep-for 3)
+                     222))))
+
+        (message \"I'm going to do some work here\") ;; ....
+
+        (message \"Waiting on async process, result should be 222: %s\"
+                 (async-get proc)))
+
+If you don't want to use a callback, and you don't care about any
+return value from the child process, pass the `ignore' symbol as
+the second argument (if you don't, and never call `async-get', it
+will leave *emacs* process buffers hanging around):
+
+    (async-start
+     (lambda ()
+       (delete-file \"a remote file on a slow link\" nil))
+     'ignore)
+
+Note: Even when FINISH-FUNC is present, a future is still
+returned except that it yields no value (since the value is
+passed to FINISH-FUNC).  Call `async-get' on such a future always
+returns nil.  It can still be useful, however, as an argument to
+`async-ready' or `async-wait'."
+  (let ((sexp start-func)
+	;; Subordinate Emacs will send text encoded in UTF-8.
+	(coding-system-for-read 'utf-8-auto))
+    (setq async--procvar
+          (async-start-process
+           "emacs" (file-truename
+                    (expand-file-name invocation-name
+                                      invocation-directory))
+           finish-func
+           async-quiet-switch "-l"
+           ;; Using `locate-library' ensure we use the right file
+           ;; when the .elc have been deleted.
+           (locate-library "async")
+           "-batch" "-f" "async-batch-invoke"
+           (if async-send-over-pipe
+               "<none>"
+               (with-temp-buffer
+                 (async--insert-sexp (list 'quote sexp))
+                 (buffer-string)))))
+    (if async-send-over-pipe
+        (async--transmit-sexp async--procvar (list 'quote sexp)))
+    async--procvar))
+
+(defmacro async-sandbox(func)
+  "Evaluate FUNC in a separate Emacs process, synchronously."
+  `(async-get (async-start ,func)))
+
+(defun async--fold-left (fn forms bindings)
+  (let ((res forms))
+    (dolist (binding bindings)
+      (setq res (funcall fn res
+                         (if (listp binding)
+                             binding
+                             (list binding)))))
+    res))
+
+(defmacro async-let (bindings &rest forms)
+  "Implements `let', but each binding is established asynchronously.
+For example:
+
+  (async-let ((x (foo))
+              (y (bar)))
+     (message \"%s %s\" x y))
+
+    expands to ==>
+
+  (async-start (foo)
+   (lambda (x)
+     (async-start (bar)
+      (lambda (y)
+        (message \"%s %s\" x y)))))"
+  (declare (indent 1))
+  (async--fold-left
+   (lambda (acc binding)
+     (let ((fun (pcase (cadr binding)
+                  ((and (pred functionp) f) f)
+                  (f `(lambda () ,f)))))
+       `(async-start ,fun
+                     (lambda (,(car binding))
+                       ,acc))))
+   `(progn ,@forms)
+   (reverse bindings)))
+
+(provide 'async)
+
+;;; async.el ends here

elpa/async-20180527.1030/dired-async.el

@@ -0,0 +1,405 @@
+;;; dired-async.el --- Asynchronous dired actions -*- lexical-binding: t -*-
+
+;; Copyright (C) 2012-2016 Free Software Foundation, Inc.
+
+;; Authors: John Wiegley <jwiegley@gmail.com>
+;;          Thierry Volpiatto <thierry.volpiatto@gmail.com>
+
+;; Keywords: dired async network
+;; X-URL: https://github.com/jwiegley/dired-async
+
+;; 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 2, 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 GNU Emacs; see the file COPYING.  If not, write to the
+;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
+
+;;; Commentary:
+
+;; This file provide a redefinition of `dired-create-file' function,
+;; performs copies, moves and all what is handled by `dired-create-file'
+;; in the background using a slave Emacs process,
+;; by means of the async.el module.
+;; To use it, put this in your .emacs:
+
+;;     (dired-async-mode 1)
+
+;; This will enable async copy/rename etc...
+;; in dired and helm.
+
+;;; Code:
+
+(require 'cl-lib)
+(require 'dired-aux)
+(require 'async)
+
+(eval-when-compile
+  (defvar async-callback))
+
+(defgroup dired-async nil
+  "Copy rename files asynchronously from dired."
+  :group 'dired)
+
+(defcustom dired-async-env-variables-regexp
+  "\\`\\(tramp-\\(default\\|connection\\|remote\\)\\|ange-ftp\\)-.*"
+  "Variables matching this regexp will be loaded on Child Emacs."
+  :type  'regexp
+  :group 'dired-async)
+
+(defcustom dired-async-message-function 'dired-async-mode-line-message
+  "Function to use to notify result when operation finish.
+Should take same args as `message'."
+  :group 'dired-async
+  :type  'function)
+
+(defcustom dired-async-log-file "/tmp/dired-async.log"
+  "File use to communicate errors from Child Emacs to host Emacs."
+  :group 'dired-async
+  :type 'string)
+
+(defcustom dired-async-mode-lighter '(:eval
+                                      (when (eq major-mode 'dired-mode)
+                                        " Async"))
+  "Mode line lighter used for `dired-async-mode'."
+  :group 'dired-async
+  :risky t
+  :type 'sexp)
+
+(defface dired-async-message
+    '((t (:foreground "yellow")))
+  "Face used for mode-line message."
+  :group 'dired-async)
+
+(defface dired-async-failures
+    '((t (:foreground "red")))
+  "Face used for mode-line message."
+  :group 'dired-async)
+
+(defface dired-async-mode-message
+    '((t (:foreground "Gold")))
+  "Face used for `dired-async--modeline-mode' lighter."
+  :group 'dired-async)
+
+(define-minor-mode dired-async--modeline-mode
+    "Notify mode-line that an async process run."
+  :group 'dired-async
+  :global t
+  :lighter (:eval (propertize (format " [%s Async job(s) running]"
+                                      (length (dired-async-processes)))
+                              'face 'dired-async-mode-message))
+  (unless dired-async--modeline-mode
+    (let ((visible-bell t)) (ding))))
+
+(defun dired-async-mode-line-message (text face &rest args)
+  "Notify end of operation in `mode-line'."
+  (message nil)
+  (let ((mode-line-format (concat
+                           " " (propertize
+                                (if args
+                                    (apply #'format text args)
+                                    text)
+                                'face face))))
+    (force-mode-line-update)
+    (sit-for 3)
+    (force-mode-line-update)))
+
+(defun dired-async-processes ()
+  (cl-loop for p in (process-list)
+           when (cl-loop for c in (process-command p) thereis
+                         (string= "async-batch-invoke" c))
+           collect p))
+
+(defun dired-async-kill-process ()
+  (interactive)
+  (let* ((processes (dired-async-processes))
+         (proc (car (last processes))))
+    (and proc (delete-process proc))
+    (unless (> (length processes) 1)
+      (dired-async--modeline-mode -1))))
+
+(defun dired-async-after-file-create (total operation failures skipped)
+  "Callback function used for operation handled by `dired-create-file'."
+  (unless (dired-async-processes)
+    ;; Turn off mode-line notification
+    ;; only when last process end.
+    (dired-async--modeline-mode -1))
+  (when operation
+    (if (file-exists-p dired-async-log-file)
+        (progn
+          (pop-to-buffer (get-buffer-create dired-log-buffer))
+          (goto-char (point-max))
+          (setq inhibit-read-only t)
+          (insert "Error: ")
+          (insert-file-contents dired-async-log-file)
+          (special-mode)
+          (shrink-window-if-larger-than-buffer)
+          (delete-file dired-async-log-file))
+        (run-with-timer
+         0.1 nil
+         (lambda ()
+           ;; First send error messages.
+           (cond (failures
+                  (funcall dired-async-message-function
+                           "%s failed for %d of %d file%s -- See *Dired log* buffer"
+                           'dired-async-failures
+                           (car operation) (length failures)
+                           total (dired-plural-s total)))
+                 (skipped
+                  (funcall dired-async-message-function
+                           "%s: %d of %d file%s skipped -- See *Dired log* buffer"
+                           'dired-async-failures
+                           (car operation) (length skipped) total
+                           (dired-plural-s total))))
+           (when dired-buffers
+             (cl-loop for (_f . b) in dired-buffers
+                      when (buffer-live-p b)
+                      do (with-current-buffer b (revert-buffer nil t))))
+           ;; Finally send the success message.
+           (funcall dired-async-message-function
+                    "Asynchronous %s of %s on %s file%s done"
+                    'dired-async-message
+                    (car operation) (cadr operation)
+                    total (dired-plural-s total)))))))
+
+(defun dired-async-maybe-kill-ftp ()
+  "Return a form to kill ftp process in child emacs."
+  (quote
+   (progn
+     (require 'cl-lib)
+     (let ((buf (cl-loop for b in (buffer-list)
+                         thereis (and (string-match
+                                       "\\`\\*ftp.*"
+                                       (buffer-name b)) b))))
+       (when buf (kill-buffer buf))))))
+
+(defvar overwrite-query)
+(defun dired-async-create-files (file-creator operation fn-list name-constructor
+                                 &optional _marker-char)
+  "Same as `dired-create-files' but asynchronous.
+
+See `dired-create-files' for the behavior of arguments."
+  (setq overwrite-query nil)
+  (let ((total (length fn-list))
+        failures async-fn-list skipped callback
+        async-quiet-switch)
+    (let (to)
+      (dolist (from fn-list)
+        (setq to (funcall name-constructor from))
+        (if (and (equal to from)
+                 (null (eq file-creator 'backup-file)))
+            (progn
+              (setq to nil)
+              (dired-log "Cannot %s to same file: %s\n"
+                         (downcase operation) from)))
+        (if (not to)
+            (setq skipped (cons (dired-make-relative from) skipped))
+            (let* ((overwrite (and (null (eq file-creator 'backup-file))
+                                   (file-exists-p to)))
+                   (dired-overwrite-confirmed ; for dired-handle-overwrite
+                    (and overwrite
+                         (let ((help-form `(format "\
+Type SPC or `y' to overwrite file `%s',
+DEL or `n' to skip to next,
+ESC or `q' to not overwrite any of the remaining files,
+`!' to overwrite all remaining files with no more questions." ,to)))
+                           (dired-query 'overwrite-query "Overwrite `%s'?" to)))))
+              ;; Handle the `dired-copy-file' file-creator specially
+              ;; When copying a directory to another directory or
+              ;; possibly to itself or one of its subdirectories.
+              ;; e.g "~/foo/" => "~/test/"
+              ;; or "~/foo/" =>"~/foo/"
+              ;; or "~/foo/ => ~/foo/bar/")
+              ;; In this case the 'name-constructor' have set the destination
+              ;; TO to "~/test/foo" because the old emacs23 behavior
+              ;; of `copy-directory' was to not create the subdirectory
+              ;; and instead copy the contents.
+              ;; With the new behavior of `copy-directory'
+              ;; (similar to the `cp' shell command) we don't
+              ;; need such a construction of the target directory,
+              ;; so modify the destination TO to "~/test/" instead of "~/test/foo/".
+              (let ((destname (file-name-directory to)))
+                (when (and (file-directory-p from)
+                           (file-directory-p to)
+                           (eq file-creator 'dired-copy-file))
+                  (setq to destname))
+                ;; If DESTNAME is a subdirectory of FROM, not a symlink,
+                ;; and the method in use is copying, signal an error.
+                (and (eq t (car (file-attributes destname)))
+                     (eq file-creator 'dired-copy-file)
+                     (file-in-directory-p destname from)
+                     (error "Cannot copy `%s' into its subdirectory `%s'"
+                            from to)))
+              (if overwrite
+                  (or (and dired-overwrite-confirmed
+                           (push (cons from to) async-fn-list))
+                      (progn
+                        (push (dired-make-relative from) failures)
+                        (dired-log "%s `%s' to `%s' failed\n"
+                                   operation from to)))
+                  (push (cons from to) async-fn-list)))))
+      ;; Fix tramp issue #80 with emacs-26, use "-q" only when needed.
+      (setq async-quiet-switch
+            (if (and (boundp 'tramp-cache-read-persistent-data)
+                     async-fn-list
+                     (cl-loop for (_from . to) in async-fn-list
+                              thereis (file-remote-p to)))
+                "-q" "-Q"))
+      ;; When failures have been printed to dired log add the date at bob.
+      (when (or failures skipped) (dired-log t))
+      ;; When async-fn-list is empty that's mean only one file
+      ;; had to be copied and user finally answer NO.
+      ;; In this case async process will never start and callback
+      ;; will have no chance to run, so notify failures here.
+      (unless async-fn-list
+        (cond (failures
+               (funcall dired-async-message-function
+                        "%s failed for %d of %d file%s -- See *Dired log* buffer"
+                        'dired-async-failures
+                        operation (length failures)
+                        total (dired-plural-s total)))
+              (skipped
+               (funcall dired-async-message-function
+                        "%s: %d of %d file%s skipped -- See *Dired log* buffer"
+                        'dired-async-failures
+                        operation (length skipped) total
+                        (dired-plural-s total)))))
+      ;; Setup callback.
+      (setq callback
+            (lambda (&optional _ignore)
+               (dired-async-after-file-create
+                total (list operation (length async-fn-list)) failures skipped)
+               (when (string= (downcase operation) "rename")
+                 (cl-loop for (file . to) in async-fn-list
+                          for bf = (get-file-buffer file)
+                          for destp = (file-exists-p to)
+                          do (and bf destp
+                                  (with-current-buffer bf
+                                    (set-visited-file-name to t t))))))))
+    ;; Start async process.
+    (when async-fn-list
+      (async-start `(lambda ()
+                      (require 'cl-lib) (require 'dired-aux) (require 'dired-x)
+                      ,(async-inject-variables dired-async-env-variables-regexp)
+                          (let ((dired-recursive-copies (quote always))
+                                (dired-copy-preserve-time
+                                 ,dired-copy-preserve-time))
+                            (setq overwrite-backup-query nil)
+                            ;; Inline `backup-file' as long as it is not
+                            ;; available in emacs.
+                            (defalias 'backup-file
+                                ;; Same feature as "cp -f --backup=numbered from to"
+                                ;; Symlinks are copied as file from source unlike
+                                ;; `dired-copy-file' which is same as cp -d.
+                                ;; Directories are omitted.
+                                (lambda (from to ok)
+                                  (cond ((file-directory-p from) (ignore))
+                                        (t (let ((count 0))
+                                             (while (let ((attrs (file-attributes to)))
+                                                      (and attrs (null (nth 0 attrs))))
+                                               (cl-incf count)
+                                               (setq to (concat (file-name-sans-versions to)
+                                                                (format ".~%s~" count)))))
+                                           (condition-case err
+                                               (copy-file from to ok dired-copy-preserve-time)
+                                             (file-date-error
+                                              (dired-log "Can't set date on %s:\n%s\n" from err)))))))
+                            ;; Now run the FILE-CREATOR function on files.
+                            (cl-loop with fn = (quote ,file-creator)
+                                     for (from . dest) in (quote ,async-fn-list)
+                                     do (condition-case err
+                                            (funcall fn from dest t)
+                                          (file-error
+                                           (dired-log "%s: %s\n" (car err) (cdr err)))
+                                          nil))
+                        (when (get-buffer dired-log-buffer)
+                          (dired-log t)
+                          (with-current-buffer dired-log-buffer
+                           (write-region (point-min) (point-max)
+                                         ,dired-async-log-file))))
+                      ,(dired-async-maybe-kill-ftp))
+                   callback)
+      ;; Run mode-line notifications while process running.
+      (dired-async--modeline-mode 1)
+      (message "%s proceeding asynchronously..." operation))))
+
+(defvar wdired-use-interactive-rename)
+(defun dired-async-wdired-do-renames (old-fn &rest args)
+  ;; Perhaps a better fix would be to ask for renaming BEFORE starting
+  ;; OLD-FN when `wdired-use-interactive-rename' is non-nil.  For now
+  ;; just bind it to nil to ensure no questions will be asked between
+  ;; each rename.
+  (let (wdired-use-interactive-rename)
+    (apply old-fn args)))
+
+(defadvice wdired-do-renames (around wdired-async)
+  (let (wdired-use-interactive-rename)
+    ad-do-it))
+
+(defadvice dired-create-files (around dired-async)
+  (dired-async-create-files file-creator operation fn-list
+                            name-constructor marker-char))
+
+;;;###autoload
+(define-minor-mode dired-async-mode
+  "Do dired actions asynchronously."
+  :group 'dired-async
+  :lighter dired-async-mode-lighter
+  :global t
+  (if dired-async-mode
+      (if (fboundp 'advice-add)
+          (progn (advice-add 'dired-create-files :override #'dired-async-create-files)
+                 (advice-add 'wdired-do-renames :around #'dired-async-wdired-do-renames))
+        (ad-activate 'dired-create-files)
+        (ad-activate 'wdired-do-renames))
+      (if (fboundp 'advice-remove)
+          (progn (advice-remove 'dired-create-files #'dired-async-create-files)
+                 (advice-remove 'wdired-do-renames #'dired-async-wdired-do-renames))
+          (ad-deactivate 'dired-create-files)
+          (ad-deactivate 'wdired-do-renames))))
+
+(defmacro dired-async--with-async-create-files (&rest body)
+  "Evaluate BODY with ‘dired-create-files’ set to ‘dired-async-create-files’."
+  (declare (indent 0))
+  `(cl-letf (((symbol-function 'dired-create-files) #'dired-async-create-files))
+     ,@body))
+
+;;;###autoload
+(defun dired-async-do-copy (&optional arg)
+  "Run ‘dired-do-copy’ asynchronously."
+  (interactive "P")
+  (dired-async--with-async-create-files
+    (dired-do-copy arg)))
+
+;;;###autoload
+(defun dired-async-do-symlink (&optional arg)
+  "Run ‘dired-do-symlink’ asynchronously."
+  (interactive "P")
+  (dired-async--with-async-create-files
+    (dired-do-symlink arg)))
+
+;;;###autoload
+(defun dired-async-do-hardlink (&optional arg)
+  "Run ‘dired-do-hardlink’ asynchronously."
+  (interactive "P")
+  (dired-async--with-async-create-files
+    (dired-do-hardlink arg)))
+
+;;;###autoload
+(defun dired-async-do-rename (&optional arg)
+  "Run ‘dired-do-rename’ asynchronously."
+  (interactive "P")
+  (dired-async--with-async-create-files
+    (dired-do-rename arg)))
+
+(provide 'dired-async)
+
+;;; dired-async.el ends here

elpa/async-20180527.1030/smtpmail-async.el

@@ -0,0 +1,73 @@
+;;; smtpmail-async.el --- Send e-mail with smtpmail.el asynchronously -*- lexical-binding: t -*-
+
+;; Copyright (C) 2012-2016 Free Software Foundation, Inc.
+
+;; Author: John Wiegley <jwiegley@gmail.com>
+;; Created: 18 Jun 2012
+
+;; Keywords: email async
+;; X-URL: https://github.com/jwiegley/emacs-async
+
+;; 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 2, 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 GNU Emacs; see the file COPYING.  If not, write to the
+;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
+
+;;; Commentary:
+
+;; Send e-mail with smtpmail.el asynchronously.  To use:
+;;
+;;   (require 'smtpmail-async)
+;;
+;;   (setq send-mail-function 'async-smtpmail-send-it
+;;         message-send-mail-function 'async-smtpmail-send-it)
+;;
+;; This assumes you already have smtpmail.el working.
+
+;;; Code:
+
+(defgroup smtpmail-async nil
+  "Send e-mail with smtpmail.el asynchronously"
+  :group 'smptmail)
+
+(require 'async)
+(require 'smtpmail)
+(require 'message)
+
+(defvar async-smtpmail-before-send-hook nil
+  "Hook running in the child emacs in `async-smtpmail-send-it'.
+It is called just before calling `smtpmail-send-it'.")
+
+(defun async-smtpmail-send-it ()
+  (let ((to          (message-field-value "To"))
+        (buf-content (buffer-substring-no-properties
+                      (point-min) (point-max))))
+    (message "Delivering message to %s..." to)
+    (async-start
+     `(lambda ()
+        (require 'smtpmail)
+        (with-temp-buffer
+          (insert ,buf-content)
+          (set-buffer-multibyte nil)
+          ;; Pass in the variable environment for smtpmail
+          ,(async-inject-variables
+            "\\`\\(smtpmail\\|async-smtpmail\\|\\(user-\\)?mail\\)-\\|auth-sources\\|epg\\|nsm"
+            nil "\\`\\(mail-header-format-function\\|smtpmail-address-buffer\\|mail-mode-abbrev-table\\)")
+          (run-hooks 'async-smtpmail-before-send-hook)
+          (smtpmail-send-it)))
+     (lambda (&optional _ignore)
+       (message "Delivering message to %s...done" to)))))
+
+(provide 'smtpmail-async)
+
+;;; smtpmail-async.el ends here

elpa/counsel-20180517.1140/counsel-pkg.el

@@ -1,2 +0,0 @@
-;;; -*- no-byte-compile: t -*-
-(define-package "counsel" "20180517.1140" "Various completion functions using Ivy" '((emacs "24.3") (swiper "0.9.0")) :commit "7df7ab6292ec85c396d85d837e820d248121ffcf" :keywords '("completion" "matching") :url "https://github.com/abo-abo/swiper")

elpa/counsel-20180608.955/counsel-autoloads.el

@@ -1,10 +1,12 @@
 ;;; counsel-autoloads.el --- automatically extracted autoloads
 ;;
 ;;; Code:
-(add-to-list 'load-path (directory-file-name (or (file-name-directory #$) (car load-path))))
+
+(add-to-list 'load-path (directory-file-name
+                         (or (file-name-directory #$) (car load-path))))
+
 
-;;;### (autoloads nil "counsel" "counsel.el" (23293 60671 657825
+;;;### (autoloads nil "counsel" "counsel.el" (0 0 0 0))
-;;;;;;  883000))
 ;;; Generated autoloads from counsel.el
 
 (autoload 'counsel-el "counsel" "\
@@ -78,6 +80,8 @@ Forward to `bookmark-jump' or `bookmark-set' if bookmark doesn't exist.
 (autoload 'counsel-M-x "counsel" "\
 Ivy version of `execute-extended-command'.
 Optional INITIAL-INPUT is the initial input in the minibuffer.
+This function integrates with either the `amx' or `smex' package
+when available, in that order of precedence.
 
 \(fn &optional INITIAL-INPUT)" t nil)
 
@@ -408,11 +412,14 @@ replacements.
 
 \(fn &optional ARG)" t nil)
 
+(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "counsel" '("counsel-" "tmm-km-list" "ivy-function-called-at-point")))
+
 ;;;***
 
 ;; Local Variables:
 ;; version-control: never
 ;; no-byte-compile: t
 ;; no-update-autoloads: t
+;; coding: utf-8
 ;; End:
 ;;; counsel-autoloads.el ends here

elpa/counsel-20180608.955/counsel-pkg.el

@@ -0,0 +1,2 @@
+;;; -*- no-byte-compile: t -*-
+(define-package "counsel" "20180608.955" "Various completion functions using Ivy" '((emacs "24.3") (swiper "0.9.0")) :commit "1355542992b518b61c9f7b6edaa6c1d8c889f700" :keywords '("completion" "matching") :url "https://github.com/abo-abo/swiper")

elpa/counsel-20180608.955/counsel.el

@@ -4,7 +4,7 @@
 
 ;; Author: Oleh Krehel <ohwoeowho@gmail.com>
 ;; URL: https://github.com/abo-abo/swiper
-;; Package-Version: 20180517.1140
+;; Package-Version: 20180608.955
 ;; Version: 0.10.0
 ;; Package-Requires: ((emacs "24.3") (swiper "0.9.0"))
 ;; Keywords: completion, matching
@@ -541,8 +541,9 @@ Variables declared using `defcustom' are highlighted according to
 (defcustom counsel-describe-function-preselect #'ivy-thing-at-point
   "Determine what `counsel-describe-function' should preselect."
   :group 'ivy
-  :type '(radio (function-item ivy-thing-at-point)
+  :type '(radio
-                (function-item ivy-function-called-at-point)))
+          (function-item ivy-thing-at-point)
+          (function-item ivy-function-called-at-point)))
 
 ;;;###autoload
 (defun counsel-describe-function ()
@@ -609,6 +610,10 @@ X is an item of a radio- or choice-type defcustom."
                   (list 'quote x)
                 x))))))
 
+(declare-function lv-message "ext:lv")
+(declare-function lv-delete-window "ext:lv")
+(declare-function custom-variable-documentation "cus-edit")
+
 ;;;###autoload
 (defun counsel-set-variable (sym)
   "Set a variable, with completion.
@@ -623,34 +628,45 @@ input corresponding to the chosen variable."
                                 (counsel-variable-list)
                                 :preselect (ivy-thing-at-point)
                                 :history 'counsel-set-variable-history))))
-  (let (sym-type
+  (let ((doc (and (require 'cus-edit)
+                  (require 'lv nil t)
+                  (not (string= "nil" (custom-variable-documentation sym)))
+                  (propertize (custom-variable-documentation sym)
+                              'face 'font-lock-comment-face)))
+        sym-type
         cands)
-    (if (and (boundp sym)
+    (unwind-protect
-             (setq sym-type (get sym 'custom-type))
+         (progn
-             (cond
+           (when doc
-               ((and (consp sym-type)
+             (lv-message doc))
-                     (memq (car sym-type) '(choice radio)))
+           (if (and (boundp sym)
-                (setq cands (delq nil (mapcar #'counsel--setq-doconst (cdr sym-type)))))
+                    (setq sym-type (get sym 'custom-type))
-               ((eq sym-type 'boolean)
+                    (cond
-                (setq cands '(("nil" . nil) ("t" . t))))
+                      ((and (consp sym-type)
-               (t nil)))
+                            (memq (car sym-type) '(choice radio)))
-        (let* ((sym-val (symbol-value sym))
+                       (setq cands (delq nil (mapcar #'counsel--setq-doconst (cdr sym-type)))))
-               ;; Escape '%' chars if present
+                      ((eq sym-type 'boolean)
-               (sym-val-str (replace-regexp-in-string "%" "%%" (format "%s" sym-val)))
+                       (setq cands '(("nil" . nil) ("t" . t))))
-               (res (ivy-read (format "Set (%S <%s>): " sym sym-val-str)
+                      (t nil)))
-                              cands
+               (let* ((sym-val (symbol-value sym))
-                              :preselect (prin1-to-string sym-val))))
+                      ;; Escape '%' chars if present
-          (when res
+                      (sym-val-str (replace-regexp-in-string "%" "%%" (format "%s" sym-val)))
-            (setq res
+                      (res (ivy-read (format "Set (%S <%s>): " sym sym-val-str)
-                  (if (assoc res cands)
+                                     cands
-                      (cdr (assoc res cands))
+                                     :preselect (prin1-to-string sym-val))))
-                    (read res)))
+                 (when res
-            (set sym (if (and (listp res) (eq (car res) 'quote))
+                   (setq res
-                         (cadr res)
+                         (if (assoc res cands)
-                       res))))
+                             (cdr (assoc res cands))
-      (unless (boundp sym)
+                           (read res)))
-        (set sym nil))
+                   (set sym (if (and (listp res) (eq (car res) 'quote))
-      (counsel-read-setq-expression sym))))
+                                (cadr res)
+                              res))))
+             (unless (boundp sym)
+               (set sym nil))
+             (counsel-read-setq-expression sym)))
+      (when doc
+        (lv-delete-window)))))
 
 ;;** `counsel-info-lookup-symbol'
 (defvar info-lookup-mode)
@@ -716,7 +732,7 @@ can use `C-x r j i' to open that file."
             (mapcar (lambda (register-alist-entry)
                       (if (eq 'file (cadr register-alist-entry))
                           (cddr register-alist-entry)))
-                      register-alist)
+                    register-alist)
             :sort t
             :require-match t
             :history 'counsel-file-register
@@ -768,9 +784,9 @@ By default `counsel-bookmark' opens a dired buffer for directories."
  `(("d" bookmark-delete "delete")
    ("e" bookmark-rename "edit")
    ("x" ,(counsel--apply-bookmark-fn #'counsel-find-file-extern)
-    "open externally")
+        "open externally")
    ("r" ,(counsel--apply-bookmark-fn #'counsel-find-file-as-root)
-    "open as root")))
+        "open as root")))
 
 (defun counsel-M-x-transformer (cmd)
   "Return CMD annotated with its active key binding, if any."
@@ -789,6 +805,12 @@ By default `counsel-bookmark' opens a dired buffer for directories."
       (put-text-property 0 (length key) 'face 'counsel-key-binding key)
       (format "%s (%s)" cmd key))))
 
+(defvar amx-initialized)
+(defvar amx-cache)
+(declare-function amx-initialize "ext:amx")
+(declare-function amx-detect-new-commands "ext:amx")
+(declare-function amx-update "ext:amx")
+(declare-function amx-rank "ext:amx")
 (defvar smex-initialized-p)
 (defvar smex-ido-cache)
 (declare-function smex-initialize "ext:smex")
@@ -796,6 +818,24 @@ By default `counsel-bookmark' opens a dired buffer for directories."
 (declare-function smex-update "ext:smex")
 (declare-function smex-rank "ext:smex")
 
+(defun counsel--M-x-externs ()
+  "Return `counsel-M-x' candidates from external packages.
+The currently supported packages are, in order of precedence,
+`amx' and `smex'."
+  (cond ((require 'amx nil t)
+         (unless amx-initialized
+           (amx-initialize))
+         (when (amx-detect-new-commands)
+           (amx-update))
+         (mapcar
+          (lambda (command-item) (symbol-name (car command-item))) amx-cache))
+        ((require 'smex nil t)
+         (unless smex-initialized-p
+           (smex-initialize))
+         (when (smex-detect-new-commands)
+           (smex-update))
+         smex-ido-cache)))
+
 (defun counsel--M-x-prompt ()
   "String for `M-x' plus the string representation of `current-prefix-arg'."
   (if (not current-prefix-arg)
@@ -816,37 +856,31 @@ By default `counsel-bookmark' opens a dired buffer for directories."
 ;;;###autoload
 (defun counsel-M-x (&optional initial-input)
   "Ivy version of `execute-extended-command'.
-Optional INITIAL-INPUT is the initial input in the minibuffer."
+Optional INITIAL-INPUT is the initial input in the minibuffer.
+This function integrates with either the `amx' or `smex' package
+when available, in that order of precedence."
   (interactive)
-  (let* ((cands obarray)
+  ;; When `counsel-M-x' returns, `last-command' would be set to
-         (pred 'commandp)
+  ;; `counsel-M-x' because :action hasn't been invoked yet.
-         (sort t))
+  ;; Instead, preserve the old value of `this-command'.
-    (when (require 'smex nil 'noerror)
+  (setq this-command last-command)
-      (unless smex-initialized-p
+  (setq real-this-command real-last-command)
-        (smex-initialize))
+  (let ((externs (counsel--M-x-externs)))
-      (when (smex-detect-new-commands)
+    (ivy-read (counsel--M-x-prompt) (or externs obarray)
-        (smex-update))
+              :predicate (and (not externs) #'commandp)
-      (setq cands smex-ido-cache)
-      (setq pred nil)
-      (setq sort nil))
-    ;; When `counsel-M-x' returns, `last-command' would be set to
-    ;; `counsel-M-x' because :action hasn't been invoked yet.
-    ;; Instead, preserve the old value of `this-command'.
-    (setq this-command last-command)
-    (setq real-this-command real-last-command)
-    (ivy-read (counsel--M-x-prompt) cands
-              :predicate pred
               :require-match t
               :history 'counsel-M-x-history
-              :action
+              :action (lambda (cmd)
-              (lambda (cmd)
+                        (setq cmd (intern cmd))
-                (when (featurep 'smex)
+                        (cond ((bound-and-true-p amx-initialized)
-                  (smex-rank (intern cmd)))
+                               (amx-rank cmd))
-                (let ((prefix-arg current-prefix-arg))
+                              ((bound-and-true-p smex-initialized-p)
-                  (setq real-this-command
+                               (smex-rank cmd)))
-                        (setq this-command (intern cmd)))
+                        (setq prefix-arg current-prefix-arg)
-                  (command-execute (intern cmd) 'record)))
+                        (setq this-command cmd)
-              :sort sort
+                        (setq real-this-command cmd)
+                        (command-execute cmd 'record))
+              :sort (not externs)
               :keymap counsel-describe-map
               :initial-input initial-input
               :caller 'counsel-M-x)))
@@ -1740,13 +1774,13 @@ The preselect behaviour can be customized via user options
 `counsel-find-file-at-point' and
 `counsel-preselect-current-file', which see."
   (or
-    (when counsel-find-file-at-point
+   (when counsel-find-file-at-point
-      (require 'ffap)
+     (require 'ffap)
-      (let ((f (ffap-guesser)))
+     (let ((f (ffap-guesser)))
-        (when f (expand-file-name f))))
+       (when f (expand-file-name f))))
-    (and counsel-preselect-current-file
+   (and counsel-preselect-current-file
-         buffer-file-name
+        buffer-file-name
-         (file-name-nondirectory buffer-file-name))))
+        (file-name-nondirectory buffer-file-name))))
 
 ;;;###autoload
 (defun counsel-find-file (&optional initial-input)
@@ -1924,7 +1958,7 @@ result as a URL."
   (ivy-read "Recentf: " (mapcar #'substring-no-properties recentf-list)
             :action (lambda (f)
                       (with-ivy-window
-                       (find-file f)))
+                        (find-file f)))
             :caller 'counsel-recentf))
 (ivy-set-actions
  'counsel-recentf
@@ -2298,10 +2332,10 @@ AG-PROMPT, if non-nil, is passed as `ivy-read' prompt argument."
                             (substring-no-properties extra-ag-args 0 args-end)
                           extra-ag-args)))
     (setq counsel-ag-command (format counsel-ag-command
-                                      (concat extra-ag-args
+                                     (concat extra-ag-args
-                                              " -- "
+                                             " -- "
-                                              "%s"
+                                             "%s"
-                                              file))))
+                                             file))))
   (ivy-set-prompt 'counsel-ag counsel-prompt-function)
   (let ((default-directory (or initial-directory
                                (locate-dominating-file default-directory ".git")
@@ -2989,14 +3023,14 @@ include attachments of other Org buffers."
   (interactive)
   (require 'org)
   (ivy-read "Entity: " (cl-loop for element in (append org-entities org-entities-user)
-                                unless (stringp element)
+                          unless (stringp element)
-                                collect (cons
+                          collect (cons
-                                         (format "%20s | %20s | %20s | %s"
+                                   (format "%20s | %20s | %20s | %s"
-                                                 (cl-first element)    ; name
+                                           (cl-first element)    ; name
-                                                 (cl-second element)   ; latex
+                                           (cl-second element)   ; latex
-                                                 (cl-fourth element)   ; html
+                                           (cl-fourth element)   ; html
-                                                 (cl-seventh element)) ; utf-8
+                                           (cl-seventh element)) ; utf-8
-                                         element))
+                                   element))
             :require-match t
             :action '(1
                       ("u" (lambda (candidate)
@@ -3040,16 +3074,16 @@ include attachments of other Org buffers."
  'counsel-org-capture
  `(("t" ,(lambda (x)
            (org-capture-goto-target (car (split-string x))))
-    "go to target")
+        "go to target")
    ("l" ,(lambda (_x)
            (org-capture-goto-last-stored))
-    "go to last stored")
+        "go to last stored")
    ("p" ,(lambda (x)
            (org-capture 0 (car (split-string x))))
-    "insert template at point")
+        "insert template at point")
    ("c" ,(lambda (_x)
            (customize-variable 'org-capture-templates))
-    "customize org-capture-templates")))
+        "customize org-capture-templates")))
 
 ;;** `counsel-mark-ring'
 (defun counsel-mark-ring ()
@@ -3284,9 +3318,10 @@ All elements of `kill-ring' for which this function returns nil
 will be destructively removed from `kill-ring' before completion.
 All blank strings are deleted from `kill-ring' by default."
   :group 'ivy
-  :type '(radio (function-item counsel-string-non-blank-p)
+  :type '(radio
-                (function-item identity)
+          (function-item counsel-string-non-blank-p)
-                (function :tag "Other")))
+          (function-item identity)
+          (function :tag "Other")))
 
 (defun counsel--yank-pop-kills ()
   "Return filtered `kill-ring' for `counsel-yank-pop' completion.
@@ -3381,9 +3416,9 @@ Note: Duplicate elements of `kill-ring' are always deleted."
               :require-match t
               :preselect (let (interprogram-paste-function)
                            (current-kill (cond
-                                          (arg (prefix-numeric-value arg))
+                                           (arg (prefix-numeric-value arg))
-                                          (counsel-yank-pop-preselect-last 0)
+                                           (counsel-yank-pop-preselect-last 0)
-                                          (t 1))
+                                           (t 1))
                                          t))
               :action #'counsel-yank-pop-action
               :caller 'counsel-yank-pop)))
@@ -4281,9 +4316,9 @@ candidate."
   "Show the history of commands."
   (interactive)
   (ivy-read "%d Command: " (mapcar #'prin1-to-string command-history)
-          :require-match t
+            :require-match t
-          :action #'counsel-command-history-action-eval
+            :action #'counsel-command-history-action-eval
-          :caller 'counsel-command-history))
+            :caller 'counsel-command-history))
 
 ;;** `counsel-org-agenda-headlines'
 (defvar org-odd-levels-only)
@@ -4370,8 +4405,8 @@ candidate."
          (beg (car symbol-bounds))
          (end (cdr symbol-bounds))
          (prefix (buffer-substring-no-properties beg end)))
-  (setq ivy-completion-beg beg
+    (setq ivy-completion-beg beg
-        ivy-completion-end end)
+          ivy-completion-end end)
     (ivy-read "code: " (mapcar #'counsel-irony-annotate candidates)
               :predicate (lambda (candidate)
                            (string-prefix-p prefix (car candidate)))

elpa/counsel-readme.txt

@@ -1,12 +0,0 @@
-Just call one of the interactive functions in this file to complete
-the corresponding thing using `ivy'.
-
-Currently available:
-- Symbol completion for Elisp, Common Lisp, Python and Clojure.
-- Describe fuctions for Elisp: function, variable, library, command,
-  bindings, theme.
-- Navigation functions: imenu, ace-line, semantic, outline
-- Git utilities: git-files, git-grep, git-log, git-stash.
-- Grep utitilies: grep, ag, pt, recoll.
-- System utilities: process list, rhythmbox, linux-app.
-- Many more.

elpa/ess-20180611.502/allnews.info

@@ -3,6 +3,15 @@ allnews.texi.
 
 Changes and New Features in development version:
 
+   * ESS[R]: Fontification of roxygen '@param' keywords now supports
+     comma-separated parameters.
+
+   * ESS[R]: Function-like keywords such as 'if ()' or 'stop()' are no
+     longer fontified as keyword if not followed by an opening
+     parenthesis.  The same holds for search path modifiers like
+     'library()' or 'require()'.  This feature is only available in
+     Emacs >= 25.
+
    * ESS modes now inherit from 'prog-mode'.
 
    * ESS[R]: The package development minor mode now only activates
@@ -63,6 +72,13 @@ Changes and New Features in development version:
      customization to 'inferior-ess-R-program'.  These variables are
      treated as risky variables.
 
+   * Customization of ess-smart-S-assign-key has been reworked.  You
+     should now set the value before ESS is loaded.  The following
+     functions have been made obsolete.  You should customize
+     ess-smart-S-assign-key instead: ess-toggle-S-assign,
+     ess-toggle-S-assign-key, ess-unset-smart-S-assign-key,
+     ess-activate-smart-S-assign-key, ess-disable-smart-S-assign
+
    Changes and New Features in 17.11:
 
    * The ESS initialisation process has been streamlined.  You can now

elpa/ess-20180611.502/announc.info

@@ -215,6 +215,15 @@ File: announc.info,  Node: New Features,  Prev: License,  Up: Announce
 
 Changes and New Features in development version:
 
+   * ESS[R]: Fontification of roxygen '@param' keywords now supports
+     comma-separated parameters.
+
+   * ESS[R]: Function-like keywords such as 'if ()' or 'stop()' are no
+     longer fontified as keyword if not followed by an opening
+     parenthesis.  The same holds for search path modifiers like
+     'library()' or 'require()'.  This feature is only available in
+     Emacs >= 25.
+
    * ESS modes now inherit from 'prog-mode'.
 
    * ESS[R]: The package development minor mode now only activates
@@ -275,6 +284,13 @@ Changes and New Features in development version:
      customization to 'inferior-ess-R-program'.  These variables are
      treated as risky variables.
 
+   * Customization of ess-smart-S-assign-key has been reworked.  You
+     should now set the value before ESS is loaded.  The following
+     functions have been made obsolete.  You should customize
+     ess-smart-S-assign-key instead: ess-toggle-S-assign,
+     ess-toggle-S-assign-key, ess-unset-smart-S-assign-key,
+     ess-activate-smart-S-assign-key, ess-disable-smart-S-assign
+
    Changes and New Features in 17.11:
 
    * The ESS initialisation process has been streamlined.  You can now

elpa/ess-20180611.502/ess-pkg.el

@@ -1,4 +1,4 @@
-(define-package "ess" "20180524.1000" "Emacs Speaks Statistics"
+(define-package "ess" "20180611.502" "Emacs Speaks Statistics"
   '((julia-mode "0.3"))
   :url "http://ess.r-project.org")
 ;; Local Variables:

elpa/ess-20180611.502/ess.info

@@ -242,6 +242,15 @@ File: ess.info,  Node: New features,  Next: Credits,  Prev: Features,  Up: Intro
 
 Changes and New Features in development version:
 
+   * ESS[R]: Fontification of roxygen '@param' keywords now supports
+     comma-separated parameters.
+
+   * ESS[R]: Function-like keywords such as 'if ()' or 'stop()' are no
+     longer fontified as keyword if not followed by an opening
+     parenthesis.  The same holds for search path modifiers like
+     'library()' or 'require()'.  This feature is only available in
+     Emacs >= 25.
+
    * ESS modes now inherit from 'prog-mode'.
 
    * ESS[R]: The package development minor mode now only activates
@@ -302,6 +311,13 @@ Changes and New Features in development version:
      customization to 'inferior-ess-R-program'.  These variables are
      treated as risky variables.
 
+   * Customization of ess-smart-S-assign-key has been reworked.  You
+     should now set the value before ESS is loaded.  The following
+     functions have been made obsolete.  You should customize
+     ess-smart-S-assign-key instead: ess-toggle-S-assign,
+     ess-toggle-S-assign-key, ess-unset-smart-S-assign-key,
+     ess-activate-smart-S-assign-key, ess-disable-smart-S-assign
+
    Changes and New Features in 17.11:
 
    * The ESS initialisation process has been streamlined.  You can now
@@ -4670,104 +4686,104 @@ Node: Introduction2347
 Node: Features5100
 Node: Current Features5936
 Node: New features9387
-Node: Credits17676
+Node: Credits18447
-Node: Manual21235
+Node: Manual22006
-Node: Installation23901
+Node: Installation24672
-Node: Latest version24337
+Node: Latest version25108
-Node: Installation instructions25098
+Node: Installation instructions25869
-Node: License28298
+Node: License29069
-Node: Stability28961
+Node: Stability29732
-Node: Requirements29458
+Node: Requirements30229
-Node: Interactive ESS30139
+Node: Interactive ESS30910
-Node: Starting up30953
+Node: Starting up31724
-Node: Multiple ESS processes31697
+Node: Multiple ESS processes32468
-Node: ESS processes on Remote Computers32778
+Node: ESS processes on Remote Computers33549
-Node: Customizing startup36880
+Node: Customizing startup37651
-Node: Entering commands39497
+Node: Entering commands40268
-Node: Command-line editing40655
+Node: Command-line editing41426
-Node: Transcript41888
+Node: Transcript42659
-Node: Last command43657
+Node: Last command44428
-Node: Process buffer motion45083
+Node: Process buffer motion45854
-Node: Transcript resubmit46586
+Node: Transcript resubmit47357
-Node: Saving transcripts48551
+Node: Saving transcripts49322
-Node: Command History50341
+Node: Command History51112
-Node: Saving History53750
+Node: Saving History54521
-Node: History expansion54511
+Node: History expansion55282
-Node: Hot keys57722
+Node: Hot keys58493
-Node: Statistical Process running in ESS?61792
+Node: Statistical Process running in ESS?62563
-Node: Emacsclient63071
+Node: Emacsclient63842
-Node: Other63863
+Node: Other64634
-Node: Evaluating code64882
+Node: Evaluating code65653
-Node: Transcript Mode68563
+Node: Transcript Mode69334
-Node: Resubmit69716
+Node: Resubmit70487
-Node: Clean70779
+Node: Clean71550
-Node: Editing objects71775
+Node: Editing objects72546
-Node: Edit buffer72893
+Node: Edit buffer73664
-Node: Loading74939
+Node: Loading75710
-Node: Error Checking75966
+Node: Error Checking76737
-Node: Indenting77015
+Node: Indenting77786
-Node: Styles80204
+Node: Styles80975
-Node: Other edit buffer commands82639
+Node: Other edit buffer commands83410
-Node: Source Files84295
+Node: Source Files85066
-Node: Source Directories88899
+Node: Source Directories89670
-Node: Help92052
+Node: Help92823
-Node: Completion96150
+Node: Completion96921
-Node: Object names96383
+Node: Object names97154
-Node: Function arguments99056
+Node: Function arguments99827
-Node: Minibuffer completion99595
+Node: Minibuffer completion100366
-Node: Auto-complete100075
+Node: Auto-complete100846
-Node: Company101622
+Node: Company102393
-Node: Icicles102001
+Node: Icicles102772
-Node: Developing with ESS103320
+Node: Developing with ESS104091
-Node: ESS tracebug103766
+Node: ESS tracebug104537
-Node: Editing documentation106924
+Node: Editing documentation107695
-Node: R documentation files107474
+Node: R documentation files108245
-Node: Roxygen111401
+Node: Roxygen112172
-Node: Namespaced Evaluation115736
+Node: Namespaced Evaluation116507
-Node: Extras117732
+Node: Extras118503
-Node: ESS ElDoc118756
+Node: ESS ElDoc119527
-Node: ESS Flymake120252
+Node: ESS Flymake121023
-Node: Handy commands121193
+Node: Handy commands121964
-Node: Highlighting122390
+Node: Highlighting123161
-Node: Parens123719
+Node: Parens124490
-Node: Graphics124195
+Node: Graphics124966
-Node: printer124866
+Node: printer125637
-Node: X11125622
+Node: X11126393
-Node: winjava125961
+Node: winjava126732
-Node: Imenu126373
+Node: Imenu127144
-Node: Toolbar127220
+Node: Toolbar127991
-Node: Xref127628
+Node: Xref128399
-Node: Rdired127951
+Node: Rdired128722
-Node: Rutils129005
+Node: Rutils129776
-Node: Org131399
+Node: Org132170
-Node: Sweave and AUCTeX132341
+Node: Sweave and AUCTeX133112
-Node: ESS for R134465
+Node: ESS for R135236
-Node: ESS(R)--Editing files134765
+Node: ESS(R)--Editing files135536
-Node: iESS(R)--Inferior ESS processes135284
+Node: iESS(R)--Inferior ESS processes136055
-Node: Philosophies for using ESS(R)140033
+Node: Philosophies for using ESS(R)140804
-Node: Example ESS usage140960
+Node: Example ESS usage141731
-Node: ESS for SAS143181
+Node: ESS for SAS143952
-Node: ESS(SAS)--Design philosophy143904
+Node: ESS(SAS)--Design philosophy144675
-Node: ESS(SAS)--Editing files144857
+Node: ESS(SAS)--Editing files145628
-Node: ESS(SAS)--TAB key146711
+Node: ESS(SAS)--TAB key147482
-Node: ESS(SAS)--Batch SAS processes148077
+Node: ESS(SAS)--Batch SAS processes148848
-Node: ESS(SAS)--Function keys for batch processing153103
+Node: ESS(SAS)--Function keys for batch processing153874
-Node: iESS(SAS)--Interactive SAS processes162589
+Node: iESS(SAS)--Interactive SAS processes163360
-Node: iESS(SAS)--Common problems166343
+Node: iESS(SAS)--Common problems167114
-Node: ESS(SAS)--Graphics167866
+Node: ESS(SAS)--Graphics168637
-Node: ESS(SAS)--Windows168649
+Node: ESS(SAS)--Windows169420
-Node: ESS for BUGS169227
+Node: ESS for BUGS169998
-Node: ESS for JAGS170983
+Node: ESS for JAGS171754
-Node: Mailing lists/bug reports174335
+Node: Mailing lists/bug reports175106
-Node: Bugs174599
+Node: Bugs175370
-Node: Reporting Bugs176224
+Node: Reporting Bugs176995
-Node: Mailing Lists177117
+Node: Mailing Lists177888
-Node: Help with Emacs177864
+Node: Help with Emacs178635
-Node: Customization178395
+Node: Customization179166
-Node: Indices179169
+Node: Indices179940
-Node: Key index179344
+Node: Key index180115
-Node: Function and program index184622
+Node: Function and program index185393
-Node: Variable index194116
+Node: Variable index194887
-Node: Concept index197604
+Node: Concept index198375
 
 End Tag Table