Merge conflict

1 files changed, 0 insertions, 1965 deletions

diff --git a/elpa/org-9.5.2/org-capture.el b/elpa/org-9.5.2/org-capture.el
deleted file mode 100644
index a9350c5..0000000
--- a/elpa/org-9.5.2/org-capture.el
+++ /dev/null
@@ -1,1965 +0,0 @@
-;;; org-capture.el --- Fast note taking in Org       -*- lexical-binding: t; -*-
-
-;; Copyright (C) 2010-2021 Free Software Foundation, Inc.
-
-;; Author: Carsten Dominik <carsten.dominik@gmail.com>
-;; Keywords: outlines, hypermedia, calendar, wp
-;; Homepage: https://orgmode.org
-;;
-;; 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 <https://www.gnu.org/licenses/>.
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;
-;;; Commentary:
-
-;; This file contains an alternative implementation of the functionality
-;; that used to be provided by org-remember.el.  The implementation is more
-;; streamlined, can produce more target types (e.g. plain list items or
-;; table lines).  Also, it does not use a temporary buffer for editing
-;; the captured entry - instead it uses an indirect buffer that visits
-;; the new entry already in the target buffer (this was an idea by Samuel
-;; Wales).  John Wiegley's excellent `remember.el' is not needed anymore
-;; for this implementation, even though we borrow heavily from its ideas.
-
-;; This implementation heavily draws on ideas by James TD Smith and
-;; Samuel Wales, and, of cause, uses John Wiegley's remember.el as inspiration.
-
-;;; TODO
-
-;; - find a clever way to not always insert an annotation maybe a
-;;   predicate function that can check for conditions for %a to be
-;;   used.  This could be one of the properties.
-
-;; - Should there be plist members that arrange for properties to be
-;;   asked for, like James proposed in his RFC?
-
-;;; Code:
-
-(require 'cl-lib)
-(require 'org)
-(require 'org-refile)
-
-(declare-function org-at-encrypted-entry-p "org-crypt" ())
-(declare-function org-at-table-p "org-table" (&optional table-type))
-(declare-function org-clock-update-mode-line "org-clock" (&optional refresh))
-(declare-function org-datetree-find-date-create "org-datetree" (date &optional keep-restriction))
-(declare-function org-datetree-find-month-create (d &optional keep-restriction))
-(declare-function org-decrypt-entry "org-crypt" ())
-(declare-function org-element-at-point "org-element" ())
-(declare-function org-element-lineage "org-element" (datum &optional types with-self))
-(declare-function org-element-property "org-element" (property element))
-(declare-function org-encrypt-entry "org-crypt" ())
-(declare-function org-insert-link "ol" (&optional complete-file link-location default-description))
-(declare-function org-link-make-string "ol" (link &optional description))
-(declare-function org-table-analyze "org-table" ())
-(declare-function org-table-current-dline "org-table" ())
-(declare-function org-table-fix-formulas "org-table" (key replace &optional limit delta remove))
-(declare-function org-table-goto-line "org-table" (N))
-
-(defvar dired-buffers)
-(defvar crm-separator)
-(defvar org-end-time-was-given)
-(defvar org-keyword-properties)
-(defvar org-remember-default-headline)
-(defvar org-remember-templates)
-(defvar org-store-link-plist)
-(defvar org-table-border-regexp)
-(defvar org-table-current-begin-pos)
-(defvar org-table-dataline-regexp)
-(defvar org-table-fix-formulas-confirm)
-(defvar org-table-hline-regexp)
-(defvar org-table-hlines)
-
-(defvar org-capture-clock-was-started nil
-  "Internal flag, noting if the clock was started.")
-
-(defvar org-capture-last-stored-marker (make-marker)
-  "Marker pointing to the entry most recently stored with `org-capture'.")
-
-;; The following variable is scoped dynamically by org-protocol
-;; to indicate that the link properties have already been stored
-(defvar org-capture-link-is-already-stored nil)
-
-(defvar org-capture-is-refiling nil
-  "Non-nil when capture process is refiling an entry.")
-
-(defvar org-capture--prompt-history-table (make-hash-table :test #'equal)
-  "Hash table for all history lists per prompt.")
-
-(defvar org-capture--prompt-history nil
-  "History list for prompt placeholders.")
-
-(defgroup org-capture nil
-  "Options concerning capturing new entries."
-  :tag "Org Capture"
-  :group 'org)
-
-(defun org-capture-upgrade-templates (templates)
-  "Update the template list to the new format.
-TEMPLATES is a template list, as in `org-capture-templates'.  The
-new format unifies all the date/week tree targets into one that
-also allows for an optional outline path to specify a target."
-  (let ((modified-templates
-	 (mapcar
-	  (lambda (entry)
-	    (pcase entry
-	      ;; Match templates with an obsolete "tree" target type. Replace
-	      ;; it with common `file+olp-datetree'.  Add new properties
-	      ;; (i.e., `:time-prompt' and `:tree-type') if needed.
-	      (`(,key ,desc ,type (file+datetree . ,path) ,tpl . ,props)
-	       `(,key ,desc ,type (file+olp+datetree ,@path) ,tpl ,@props))
-	      (`(,key ,desc ,type (file+datetree+prompt . ,path) ,tpl . ,props)
-	       `(,key ,desc ,type (file+olp+datetree ,@path) ,tpl
-		      :time-prompt t ,@props))
-	      (`(,key ,desc ,type (file+weektree . ,path) ,tpl . ,props)
-	       `(,key ,desc ,type (file+olp+datetree ,@path) ,tpl
-		      :tree-type week ,@props))
-	      (`(,key ,desc ,type (file+weektree+prompt . ,path) ,tpl . ,props)
-	       `(,key ,desc ,type (file+olp+datetree ,@path) ,tpl
-		      :tree-type week :time-prompt t ,@props))
-	      ;; Other templates are left unchanged.
-	      (_ entry)))
-	  templates)))
-    (unless (equal modified-templates templates)
-      (message "Deprecated date/weektree capture templates changed to `file+olp+datetree'."))
-    modified-templates))
-
-(defcustom org-capture-templates nil
-  "Templates for the creation of new entries.
-
-Each entry is a list with the following items:
-
-keys         The keys that will select the template, as a string, characters
-             only, for example \"a\" for a template to be selected with a
-             single key, or \"bt\" for selection with two keys.  When using
-             several keys, keys using the same prefix key must be together
-             in the list and preceded by a 2-element entry explaining the
-             prefix key, for example
-
-                     (\"b\" \"Templates for marking stuff to buy\")
-
-             The \"C\" key is used by default for quick access to the
-             customization of the template variable.  But if you want to use
-             that key for a template, you can.
-
-description  A short string describing the template, will be shown during
-             selection.
-
-type         The type of entry.  Valid types are:
-               entry       an Org node, with a headline.  Will be filed
-                           as the child of the target entry or as a
-                           top-level entry.  Its default template is:
-                             \"* %?\n %a\"
-               item        a plain list item, will be placed in the
-                           first plain list at the target location.
-                           Its default template is:
-                             \"- %?\"
-               checkitem   a checkbox item.  This differs from the
-                           plain list item only in so far as it uses a
-                           different default template.  Its default
-                           template is:
-                             \"- [ ] %?\"
-               table-line  a new line in the first table at target location.
-                           Its default template is:
-                             \"| %? |\"
-               plain       text to be inserted as it is.
-
-target       Specification of where the captured item should be placed.
-             In Org files, targets usually define a node.  Entries will
-             become children of this node, other types will be added to the
-             table or list in the body of this node.
-
-             Most target specifications contain a file name.  If that file
-             name is the empty string, it defaults to `org-default-notes-file'.
-             A file can also be given as a variable or as a function called
-             with no argument.  When an absolute path is not specified for a
-             target, it is taken as relative to `org-directory'.
-
-             Valid values are:
-
-             (file \"path/to/file\")
-                 Text will be placed at the beginning or end of that file
-
-             (id \"id of existing Org entry\")
-                 File as child of this entry, or in the body of the entry
-
-             (file+headline \"path/to/file\" \"node headline\")
-                 Fast configuration if the target heading is unique in the file
-
-             (file+olp \"path/to/file\" \"Level 1 heading\" \"Level 2\" ...)
-                 For non-unique headings, the full outline path is safer
-
-             (file+regexp  \"path/to/file\" \"regexp to find location\")
-                 File to the entry matching regexp
-
-             (file+olp+datetree \"path/to/file\" \"Level 1 heading\" ...)
-                 Will create a heading in a date tree for today's date.
-                 If no heading is given, the tree will be on top level.
-                 To prompt for date instead of using TODAY, use the
-                 :time-prompt property.  To create a week-tree, use the
-                 :tree-type property.
-
-             (file+function \"path/to/file\" function-finding-location)
-                 A function to find the right location in the file
-
-             (clock)
-                File to the entry that is currently being clocked
-
-             (function function-finding-location)
-                Most general way: write your own function which both visits
-                the file and moves point to the right location
-
-template     The template for creating the capture item.
-             If it is an empty string or nil, a default template based on
-             the entry type will be used (see the \"type\" section above).
-             Instead of a string, this may also be one of:
-
-                 (file \"/path/to/template-file\")
-                 (function function-returning-the-template)
-
-             in order to get a template from a file, or dynamically
-             from a function.
-
-The rest of the entry is a property list of additional options.  Recognized
-properties are:
-
- :prepend            Normally newly captured information will be appended at
-                     the target location (last child, last table line,
-                     last list item...).  Setting this property will
-                     change that.
-
- :immediate-finish   When set, do not offer to edit the information, just
-                     file it away immediately.  This makes sense if the
-                     template only needs information that can be added
-                     automatically.
-
- :jump-to-captured   When set, jump to the captured entry when finished.
-
- :refile-targets     When exiting capture mode via `org-capture-refile', the
-                     variable `org-refile-targets' will be temporarily bound
-                     to the value of this property.
-
- :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 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 that should be inserted
-                     after the new item.  Overrides :empty-lines for the
-                     number of lines inserted after.
-
- :clock-in           Start the clock in this item.
-
- :clock-keep         Keep the clock running when filing the captured entry.
-
- :clock-resume       Start the interrupted clock when finishing the capture.
-                     Note that :clock-keep has precedence over :clock-resume.
-                     When setting both to t, the current clock will run and
-                     the previous one will not be resumed.
-
- :time-prompt        Prompt for a date/time to be used for date/week trees
-                     and when filling the template.
-
- :tree-type          When `week', make a week tree instead of the month-day
-                     tree.  When `month', make a month tree instead of the
-                     month-day tree.
-
- :unnarrowed         Do not narrow the target buffer, simply show the
-                     full buffer.  Default is to narrow it so that you
-                     only see the new stuff.
-
- :table-line-pos     Specification of the location in the table where the
-                     new line should be inserted.  It should be a string like
-                     \"II-3\", meaning that the new line should become the
-                     third line before the second horizontal separator line.
-
- :kill-buffer        If the target file was not yet visited by a buffer when
-                     capture was invoked, kill the buffer again after capture
-                     is finalized.
-
- :no-save            Do not save the target file after finishing the capture.
-
-The template defines the text to be inserted.  Often this is an
-Org mode entry (so the first line should start with a star) that
-will be filed as a child of the target headline.  It can also be
-freely formatted text.  Furthermore, the following %-escapes will
-be replaced with content and expanded:
-
-  %[pathname] Insert the contents of the file given by
-              `pathname'.  These placeholders are expanded at the very
-              beginning of the process so they can be used to extend the
-              current template.
-  %(sexp)     Evaluate elisp `(sexp)' and replace it with the results.
-              Only placeholders pre-existing within the template, or
-              introduced with %[pathname] are expanded this way.
-              Since this happens after expanding non-interactive
-              %-escapes, those can be used to fill the expression.
-  %<...>      The result of `format-time-string' on the ... format
-              specification.
-  %t          Time stamp, date only.  The time stamp is the current
-              time, except when called from agendas with
-              `\\[org-agenda-capture]' or with
-              `org-capture-use-agenda-date' set.
-  %T          Time stamp as above, with date and time.
-  %u, %U      Like the above, but inactive time stamps.
-  %i          Initial content, copied from the active region.  If
-              there is text before %i on the same line, such as
-              indentation, and %i is not inside a %(sexp), that prefix
-              will be added before every line in the inserted text.
-  %a          Annotation, normally the link created with `org-store-link'.
-  %A          Like %a, but prompt for the description part.
-  %l          Like %a, but only insert the literal link.
-  %L          Like %l, but without brackets (the link content itself).
-  %c          Current kill ring head.
-  %x          Content of the X clipboard.
-  %k          Title of currently clocked task.
-  %K          Link to currently clocked task.
-  %n          User name (taken from the variable `user-full-name').
-  %f          File visited by current buffer when `org-capture' was called.
-  %F          Full path of the file or directory visited by current buffer.
-  %:keyword   Specific information for certain link types, see below.
-  %^g         Prompt for tags, with completion on tags in target file.
-  %^G         Prompt for tags, with completion on all tags in all agenda files.
-  %^t         Like %t, but prompt for date.  Similarly %^T, %^u, %^U.
-              You may define a prompt like: %^{Please specify birthday}t.
-              The default date is that of %t, see above.
-  %^C         Interactive selection of which kill or clip to use.
-  %^L         Like %^C, but insert as link.
-  %^{prop}p   Prompt the user for a value for property `prop'.
-              A default value can be specified like this:
-              %^{prop|default}p.
-  %^{prompt}  Prompt the user for a string and replace this sequence with it.
-              A default value and a completion table can be specified like this:
-              %^{prompt|default|completion2|completion3|...}.
-  %?          After completing the template, position cursor here.
-  %\\1 ... %\\N Insert the text entered at the nth %^{prompt}, where N
-              is a number, starting from 1.
-
-Apart from these general escapes, you can access information specific to
-the link type that is created.  For example, calling `org-capture' in emails
-or in Gnus will record the author and the subject of the message, which you
-can access with \"%:from\" and \"%:subject\", respectively.  Here is a
-complete list of what is recorded for each link type.
-
-Link type               |  Available information
-------------------------+------------------------------------------------------
-bbdb                    |  %:type %:name %:company
-vm, wl, mh, mew, rmail, |  %:type %:subject %:message-id
-gnus                    |  %:from %:fromname %:fromaddress
-                        |  %:to   %:toname   %:toaddress
-                        |  %:fromto (either \"to NAME\" or \"from NAME\")
-                        |  %:date %:date-timestamp (as active timestamp)
-                        |  %:date-timestamp-inactive (as inactive timestamp)
-gnus                    |  %:group, for messages also all email fields
-eww, w3, w3m            |  %:type %:url
-info                    |  %:type %:file %:node
-calendar                |  %:type %:date
-
-When you need to insert a literal percent sign in the template,
-you can escape ambiguous cases with a backward slash, e.g., \\%i."
-  :group 'org-capture
-  :package-version '(Org . "9.5")
-  :set (lambda (s v) (set s (org-capture-upgrade-templates v)))
-  :type
-  (let ((file-variants '(choice :tag "Filename       "
-				(file :tag "Literal")
-				(function :tag "Function")
-				(variable :tag "Variable")
-				(sexp :tag "Form"))))
-    `(repeat
-      (choice :value ("" "" entry (file "~/org/notes.org") "")
-	      (list :tag "Multikey description"
-		    (string :tag "Keys       ")
-		    (string :tag "Description"))
-	      (list :tag "Template entry"
-		    (string :tag "Keys           ")
-		    (string :tag "Description    ")
-		    (choice :tag "Capture Type   " :value entry
-			    (const :tag "Org entry" entry)
-			    (const :tag "Plain list item" item)
-			    (const :tag "Checkbox item" checkitem)
-			    (const :tag "Plain text" plain)
-			    (const :tag "Table line" table-line))
-		    (choice :tag "Target location"
-			    (list :tag "File"
-				  (const :format "" file)
-				  ,file-variants)
-			    (list :tag "ID"
-				  (const :format "" id)
-				  (string :tag "  ID"))
-			    (list :tag "File & Headline"
-				  (const :format "" file+headline)
-				  ,file-variants
-				  (string :tag "  Headline"))
-			    (list :tag "File & Outline path"
-				  (const :format "" file+olp)
-				  ,file-variants
-				  (repeat :tag "Outline path" :inline t
-					  (string :tag "Headline")))
-			    (list :tag "File & Regexp"
-				  (const :format "" file+regexp)
-				  ,file-variants
-				  (regexp :tag "  Regexp"))
-			    (list :tag "File [ & Outline path ] & Date tree"
-				  (const :format "" file+olp+datetree)
-				  ,file-variants
-				  (option (repeat :tag "Outline path" :inline t
-						  (string :tag "Headline"))))
-			    (list :tag "File & function"
-				  (const :format "" file+function)
-				  ,file-variants
-				  (sexp :tag "  Function"))
-			    (list :tag "Current clocking task"
-				  (const :format "" clock))
-			    (list :tag "Function"
-				  (const :format "" function)
-				  (sexp :tag "  Function")))
-		    (choice :tag "Template       "
-			    (string)
-			    (list :tag "File"
-				  (const :format "" file)
-				  (file :tag "Template file"))
-			    (list :tag "Function"
-				  (const :format "" function)
-				  (function :tag "Template function")))
-		    (plist :inline t
-			   ;; Give the most common options as checkboxes
-			   :options (((const :format "%v " :prepend) (const t))
-				     ((const :format "%v " :immediate-finish) (const t))
-				     ((const :format "%v " :jump-to-captured) (const t))
-				     ((const :format "%v " :empty-lines) (const 1))
-				     ((const :format "%v " :empty-lines-before) (const 1))
-				     ((const :format "%v " :empty-lines-after) (const 1))
-				     ((const :format "%v " :clock-in) (const t))
-				     ((const :format "%v " :clock-keep) (const t))
-				     ((const :format "%v " :clock-resume) (const t))
-				     ((const :format "%v " :time-prompt) (const t))
-				     ((const :format "%v " :tree-type) (const week))
-				     ((const :format "%v " :unnarrowed) (const t))
-				     ((const :format "%v " :table-line-pos) (string))
-				     ((const :format "%v " :kill-buffer) (const t)))))))))
-
-(defcustom org-capture-before-finalize-hook nil
-  "Hook that is run right before a capture process is finalized.
-The capture buffer is still current when this hook runs and it is
-widened to the entire buffer."
-  :group 'org-capture
-  :version "24.1"
-  :type 'hook)
-
-(defcustom org-capture-after-finalize-hook nil
-  "Hook that is run right after a capture process is finalized.
-Suitable for window cleanup."
-  :group 'org-capture
-  :version "24.1"
-  :type 'hook)
-
-(defcustom org-capture-prepare-finalize-hook nil
-  "Hook that is run before the finalization starts.
-The capture buffer is current and still narrowed."
-  :group 'org-capture
-  :version "24.1"
-  :type 'hook)
-
-(defcustom org-capture-bookmark t
-  "When non-nil, add bookmark pointing at the last stored position when capturing."
-  :group 'org-capture
-  :version "24.3"
-  :type 'boolean)
-
-;;; The property list for keeping information about the capture process
-
-(defvar org-capture-plist nil
-  "Plist for the current capture process, global, to avoid having to pass it.")
-
-(defvar org-capture-current-plist nil
-  "Local variable holding the plist in a capture buffer.
-This is used to store the plist for use when finishing a capture process
-because another such process might have changed the global variable by then.
-
-Each time a new capture buffer has been set up, the global `org-capture-plist'
-is copied to this variable, which is local in the indirect buffer.")
-
-(defvar org-capture-clock-keep nil
-  "Local variable to store the value of the :clock-keep parameter.
-This is needed in case `org-capture-finalize' is called interactively.")
-
-(defun org-capture-put (&rest elements)
-  "Add ELEMENTS to the capture property list `org-capture-plist'."
-  (while elements
-    (setq org-capture-plist (plist-put org-capture-plist
-				       (pop elements) (pop elements)))))
-(defun org-capture-get (property &optional local)
-  "Get PROPERTY from the capture property list `org-capture-plist'.
-When LOCAL is set, use the local variable `org-capture-current-plist',
-this is necessary after initialization of the capture process,
-to avoid conflicts with other active capture processes."
-  (plist-get (if local org-capture-current-plist org-capture-plist) property))
-
-;;; The minor mode
-
-(defvar org-capture-mode-map
-  (let ((map (make-sparse-keymap)))
-    (define-key map "\C-c\C-c" #'org-capture-finalize)
-    (define-key map "\C-c\C-k" #'org-capture-kill)
-    (define-key map "\C-c\C-w" #'org-capture-refile)
-    map)
-  "Keymap for `org-capture-mode', a minor mode.
-Use this map to set additional keybindings for when Org mode is used
-for a capture buffer.")
-
-(defvar org-capture-mode-hook nil
-  "Hook for the `org-capture-mode' minor mode.")
-
-(define-minor-mode org-capture-mode
-  "Minor mode for special key bindings in a capture buffer.
-
-Turning on this mode runs the normal hook `org-capture-mode-hook'."
-  :lighter " Cap"
-  (setq-local
-   header-line-format
-   (substitute-command-keys
-    "\\<org-capture-mode-map>Capture buffer.  Finish \
-`\\[org-capture-finalize]', refile `\\[org-capture-refile]', \
-abort `\\[org-capture-kill]'.")))
-
-;;; The main commands
-
-(defvar org-capture-initial nil)
-(defvar org-capture-entry nil)
-
-;;;###autoload
-(defun org-capture-string (string &optional keys)
-  "Capture STRING with the template selected by KEYS."
-  (interactive "sInitial text: \n")
-  (let ((org-capture-initial string)
-	(org-capture-entry (org-capture-select-template keys)))
-    (org-capture)))
-
-(defcustom org-capture-templates-contexts nil
-  "Alist of capture templates and valid contexts.
-
-For example, if you have a capture template \"c\" and you want
-this template to be accessible only from `message-mode' buffers,
-use this:
-
-   \\='((\"c\" ((in-mode . \"message-mode\"))))
-
-Here are the available contexts definitions:
-
-      in-file: command displayed only in matching files
-      in-mode: command displayed only in matching modes
-  not-in-file: command not displayed in matching files
-  not-in-mode: command not displayed in matching modes
-    in-buffer: command displayed only in matching buffers
-not-in-buffer: command not displayed in matching buffers
-   [function]: a custom function taking no argument
-
-If you define several checks, the agenda command will be
-accessible if there is at least one valid check.
-
-You can also bind a key to another capture template depending on
-contextual rules.
-
-    \\='((\"c\" \"d\" ((in-mode . \"message-mode\"))))
-
-Here it means: in `message-mode buffers', use \"c\" as the
-key for the capture template otherwise associated with \"d\".
-\(The template originally associated with \"d\" is not displayed
-to avoid duplicates.)"
-  :version "24.3"
-  :group 'org-capture
-  :type '(repeat (list :tag "Rule"
-		       (string :tag "        Capture key")
-		       (string :tag "Replace by template")
-		       (repeat :tag "Available when"
-			       (choice
-			        (cons :tag "Condition"
-				      (choice
-				       (const :tag "In file" in-file)
-				       (const :tag "Not in file" not-in-file)
-				       (const :tag "In buffer" in-buffer)
-				       (const :tag "Not in buffer" not-in-buffer)
-				       (const :tag "In mode" in-mode)
-				       (const :tag "Not in mode" not-in-mode))
-				      (regexp))
-			        (function :tag "Custom function"))))))
-
-(defcustom org-capture-use-agenda-date nil
-  "Non-nil means use the date at point when capturing from agendas.
-When nil, you can still capture using the date at point with
-`\\[org-agenda-capture]'."
-  :group 'org-capture
-  :version "24.3"
-  :type 'boolean)
-
-;;;###autoload
-(defun org-capture (&optional goto keys)
-  "Capture something.
-\\<org-capture-mode-map>
-This will let you select a template from `org-capture-templates', and
-then file the newly captured information.  The text is immediately
-inserted at the target location, and an indirect buffer is shown where
-you can edit it.  Pressing `\\[org-capture-finalize]' brings you back to the \
-previous
-state of Emacs, so that you can continue your work.
-
-When called interactively with a `\\[universal-argument]' prefix argument \
-GOTO, don't
-capture anything, just go to the file/headline where the selected
-template stores its notes.
-
-With a `\\[universal-argument] \\[universal-argument]' prefix argument, go to \
-the last note stored.
-
-When called with a `C-0' (zero) prefix, insert a template at point.
-
-When called with a `C-1' (one) prefix, force prompting for a date when
-a datetree entry is made.
-
-ELisp programs can set KEYS to a string associated with a template
-in `org-capture-templates'.  In this case, interactive selection
-will be bypassed.
-
-If `org-capture-use-agenda-date' is non-nil, capturing from the
-agenda will use the date at point as the default date.  Then, a
-`C-1' prefix will tell the capture process to use the HH:MM time
-of the day at point (if any) or the current HH:MM time."
-  (interactive "P")
-  (when (and org-capture-use-agenda-date
-	     (eq major-mode 'org-agenda-mode))
-    (setq org-overriding-default-time
-	  (org-get-cursor-date (equal goto 1))))
-  (cond
-   ((equal goto '(4))  (org-capture-goto-target keys))
-   ((equal goto '(16)) (org-capture-goto-last-stored))
-   (t
-    (let* ((orig-buf (current-buffer))
-	   (annotation (if (and (boundp 'org-capture-link-is-already-stored)
-				org-capture-link-is-already-stored)
-			   (plist-get org-store-link-plist :annotation)
-			 (ignore-errors (org-store-link nil))))
-	   (entry (or org-capture-entry (org-capture-select-template keys)))
-	   initial)
-      (setq initial (or org-capture-initial
-			(and (org-region-active-p)
-			     (buffer-substring (point) (mark)))))
-      (when (stringp initial)
-	(remove-text-properties 0 (length initial) '(read-only t) initial))
-      (when (stringp annotation)
-	(remove-text-properties 0 (length annotation)
-				'(read-only t) annotation))
-      (cond
-       ((equal entry "C")
-	(customize-variable 'org-capture-templates))
-       ((equal entry "q")
-	(user-error "Abort"))
-       (t
-	(org-capture-set-plist entry)
-	(org-capture-get-template)
-	(org-capture-put :original-buffer orig-buf
-			 :original-file (or (buffer-file-name orig-buf)
-					    (and (featurep 'dired)
-						 (car (rassq orig-buf
-							     dired-buffers))))
-			 :original-file-nondirectory
-			 (and (buffer-file-name orig-buf)
-			      (file-name-nondirectory
-			       (buffer-file-name orig-buf)))
-			 :annotation annotation
-			 :initial initial
-			 :return-to-wconf (current-window-configuration)
-			 :default-time (or org-overriding-default-time
-					   (org-current-time)))
-	(org-capture-set-target-location (and (equal goto 0) 'here))
-	(condition-case error
-	    (org-capture-put :template (org-capture-fill-template))
-	  ((error quit)
-	   (if (get-buffer "*Capture*") (kill-buffer "*Capture*"))
-	   (error "Capture abort: %s" (error-message-string error))))
-
-	(setq org-capture-clock-keep (org-capture-get :clock-keep))
-	(condition-case error
-	    (org-capture-place-template
-	     (eq (car (org-capture-get :target)) 'function))
-	  ((error quit)
-	   (when (and (buffer-base-buffer (current-buffer))
-		      (string-prefix-p "CAPTURE-" (buffer-name)))
-	     (kill-buffer (current-buffer)))
-	   (set-window-configuration (org-capture-get :return-to-wconf))
-	   (error "Capture template `%s': %s"
-		  (org-capture-get :key)
-		  (error-message-string error))))
-	(when (and (derived-mode-p 'org-mode) (org-capture-get :clock-in))
-	  (condition-case nil
-	      (progn
-		(when (org-clock-is-active)
-		  (org-capture-put :interrupted-clock
-				   (copy-marker org-clock-marker)))
-		(org-clock-in)
-		(setq-local org-capture-clock-was-started t))
-	    (error "Could not start the clock in this capture buffer")))
-	(when (org-capture-get :immediate-finish)
-	  (org-capture-finalize))))))))
-
-(defun org-capture-get-template ()
-  "Get the template from a file or a function if necessary."
-  (org-capture-put
-   :template
-   (pcase (org-capture-get :template)
-     (`nil "")
-     ((and (pred stringp) template) template)
-     (`(file ,file)
-      (let ((filename (expand-file-name file org-directory)))
-	(if (file-exists-p filename) (org-file-contents filename)
-	  (format "* Template file %S not found" file))))
-     (`(function ,f)
-      (if (functionp f) (funcall f)
-	(format "* Template function %S not found" f)))
-     (_ "* Invalid capture template"))))
-
-(defun org-capture-finalize (&optional stay-with-capture)
-  "Finalize the capture process.
-With prefix argument STAY-WITH-CAPTURE, jump to the location of the
-captured item after finalizing."
-  (interactive "P")
-  (when (org-capture-get :jump-to-captured)
-    (setq stay-with-capture t))
-  (unless (and org-capture-mode
-	       (buffer-base-buffer (current-buffer)))
-    (error "This does not seem to be a capture buffer for Org mode"))
-
-  (run-hooks 'org-capture-prepare-finalize-hook)
-
-  ;; Update `org-capture-plist' with the buffer-local value.  Since
-  ;; captures can be run concurrently, this is to ensure that
-  ;; `org-capture-after-finalize-hook' accesses the proper plist.
-  (setq org-capture-plist org-capture-current-plist)
-
-  ;; Did we start the clock in this capture buffer?
-  (when (and org-capture-clock-was-started
-	     org-clock-marker
-	     (eq (marker-buffer org-clock-marker) (buffer-base-buffer))
-	     (>= org-clock-marker (point-min))
-	     (< org-clock-marker (point-max)))
-    ;; Looks like the clock we started is still running.
-    (if org-capture-clock-keep
-	;; User may have completed clocked heading from the template.
-	;; Refresh clock mode line.
-	(org-clock-update-mode-line t)
-      ;; Clock out.  Possibly resume interrupted clock.
-      (let (org-log-note-clock-out) (org-clock-out))
-      (when (and (org-capture-get :clock-resume 'local)
-		 (markerp (org-capture-get :interrupted-clock 'local))
-		 (buffer-live-p (marker-buffer
-				 (org-capture-get :interrupted-clock 'local))))
-	(let ((clock-in-task (org-capture-get :interrupted-clock 'local)))
-	  (org-with-point-at clock-in-task (org-clock-in)))
-	(message "Interrupted clock has been resumed"))))
-
-  (let ((abort-note nil))
-    ;; Store the size of the capture buffer
-    (org-capture-put :captured-entry-size (- (point-max) (point-min)))
-    (widen)
-    ;; Store the insertion point in the target buffer
-    (org-capture-put :insertion-point (point))
-
-    (if org-note-abort
-	(let ((beg (org-capture-get :begin-marker 'local))
-	      (end (org-capture-get :end-marker 'local)))
-	  (if (not (and beg end)) (setq abort-note 'dirty)
-	    (setq abort-note t)
-	    (org-with-wide-buffer (kill-region beg end))))
-
-      ;; Postprocessing:  Update Statistics cookies, do the sorting
-      (when (derived-mode-p 'org-mode)
-	(save-excursion
-	  (when (ignore-errors (org-back-to-heading))
-	    (org-update-parent-todo-statistics)
-	    (org-update-checkbox-count)))
-	;; FIXME Here we should do the sorting
-	;; If we have added a table line, maybe recompute?
-	(when (and (eq (org-capture-get :type 'local) 'table-line)
-		   (org-at-table-p))
-	  (if (not (org-table-get-stored-formulas)) (org-table-align)
-	    ;; Adjust formulas, if necessary.  We assume a non-nil
-	    ;; `:immediate-finish' means that no confirmation is
-	    ;; required.  Else, obey `org-table-fix-formulas-confirm'.
-	    ;;
-	    ;; The delta required to fix formulas depends on the
-	    ;; number of rows inserted by the template.
-	    (when (or (org-capture-get :immediate-finish)
-		      (not org-table-fix-formulas-confirm)
-		      (funcall org-table-fix-formulas-confirm "Fix formulas? "))
-	      (org-table-fix-formulas
-	       "@" nil (1- (org-table-current-dline))
-	       (count-lines (org-capture-get :begin-marker 'local)
-			    (org-capture-get :end-marker 'local))))
-	    (org-table-recalculate 'all)))) ;FIXME: should we iterate?
-      ;; Store this place as the last one where we stored something
-      ;; Do the marking in the base buffer, so that it makes sense after
-      ;; the indirect buffer has been killed.
-      (org-capture-store-last-position)
-
-      ;; Run the hook
-      (run-hooks 'org-capture-before-finalize-hook))
-
-    (when (org-capture-get :decrypted)
-      (save-excursion
-	(goto-char (org-capture-get :decrypted))
-	(org-encrypt-entry)))
-
-    (unless (org-capture-get :no-save) (save-buffer))
-
-    (let ((return-wconf (org-capture-get :return-to-wconf 'local))
-	  (new-buffer (org-capture-get :new-buffer 'local))
-	  (kill-buffer (org-capture-get :kill-buffer 'local))
-	  (base-buffer (buffer-base-buffer (current-buffer))))
-
-      ;; Kill the indirect buffer
-      (kill-buffer (current-buffer))
-
-      ;; Narrow back the target buffer to its previous state
-      (with-current-buffer (org-capture-get :buffer)
-        (let ((reg (org-capture-get :initial-target-region))
-	      (pos (org-capture-get :initial-target-position))
-	      (ipt (org-capture-get :insertion-point))
-	      (size (org-capture-get :captured-entry-size)))
-	  (if (not reg)
-	      (widen)
-	    (cond ((< ipt (car reg))
-		   ;; insertion point is before the narrowed region
-		   (narrow-to-region (+ size (car reg)) (+ size (cdr reg))))
-		  ((> ipt (cdr reg))
-		   ;; insertion point is after the narrowed region
-		   (narrow-to-region (car reg) (cdr reg)))
-		  (t
-		   ;; insertion point is within the narrowed region
-		   (narrow-to-region (car reg) (+ size (cdr reg)))))
-	    ;; now place back the point at its original position
-	    (if (< ipt (car reg))
-		(goto-char (+ size pos))
-	      (goto-char (if (< ipt pos) (+ size pos) pos))))))
-
-      ;; Kill the target buffer if that is desired
-      (when (and base-buffer new-buffer kill-buffer)
-	(with-current-buffer base-buffer (save-buffer))
-	(kill-buffer base-buffer))
-
-      ;; Restore the window configuration before capture
-      (set-window-configuration return-wconf))
-
-    (run-hooks 'org-capture-after-finalize-hook)
-    ;; Special cases
-    (cond
-     (abort-note
-      (cl-case abort-note
-	(clean
-	 (message "Capture process aborted and target buffer cleaned up"))
-	(dirty
-	 (error "Capture process aborted, but target buffer could not be \
-cleaned up correctly"))))
-     (stay-with-capture
-      (org-capture-goto-last-stored)))
-    ;; Return if we did store something
-    (not abort-note)))
-
-(defun org-capture-refile ()
-  "Finalize the current capture and then refile the entry.
-Refiling is done from the base buffer, because the indirect buffer is then
-already gone.  Any prefix argument will be passed to the refile command."
-  (interactive)
-  (unless (eq (org-capture-get :type 'local) 'entry)
-    (user-error "Refiling from a capture buffer makes only sense \
-for `entry'-type templates"))
-  (let* ((base (or (buffer-base-buffer) (current-buffer)))
-	 (pos (make-marker))
-	 (org-capture-is-refiling t)
-	 (kill-buffer (org-capture-get :kill-buffer 'local))
-	 (jump-to-captured (org-capture-get :jump-to-captured 'local))
-	 (refile-targets (org-capture-get :refile-targets 'local)))
-    ;; Since `org-capture-finalize' may alter buffer contents (e.g.,
-    ;; empty lines) around entry, use a marker to refer to the
-    ;; headline to be refiled.  Place the marker in the base buffer,
-    ;; as the current indirect one is going to be killed.
-    (set-marker pos (save-excursion (org-back-to-heading t) (point)) base)
-    ;; `org-capture-finalize' calls `org-capture-goto-last-stored' too
-    ;; early.  We want to wait for the refiling to be over, so we
-    ;; control when the latter function is called.
-    (org-capture-put :kill-buffer nil :jump-to-captured nil)
-    (let ((org-refile-targets (or refile-targets org-refile-targets)))
-      (org-capture-finalize)
-      (save-window-excursion
-        (with-current-buffer base
-	  (org-with-point-at pos
-	    (call-interactively 'org-refile)))))
-    (when kill-buffer
-      (with-current-buffer base (save-buffer))
-      (kill-buffer base))
-    (when jump-to-captured (org-capture-goto-last-stored))))
-
-(defun org-capture-kill ()
-  "Abort the current capture process."
-  (interactive)
-  ;; FIXME: This does not do the right thing, we need to remove the
-  ;; new stuff by hand it is easy: undo, then kill the buffer
-  (let ((org-note-abort t)
-	(org-capture-before-finalize-hook nil))
-    (org-capture-finalize)))
-
-(defun org-capture-goto-last-stored ()
-  "Go to the location where the last capture note was stored."
-  (interactive)
-  (org-goto-marker-or-bmk org-capture-last-stored-marker
-			  (plist-get org-bookmark-names-plist
-				     :last-capture))
-  (message "This is the last note stored by a capture process"))
-
-;;; Supporting functions for handling the process
-
-(defun org-capture-put-target-region-and-position ()
-  "Store the initial region with `org-capture-put'."
-  (org-capture-put
-   :initial-target-region
-   ;; Check if the buffer is currently narrowed
-   (when (org-buffer-narrowed-p)
-     (cons (point-min) (point-max))))
-  ;; store the current point
-  (org-capture-put :initial-target-position (point)))
-
-(defvar org-time-was-given) ; dynamically scoped parameter
-(defun org-capture-set-target-location (&optional target)
-  "Find TARGET buffer and position.
-Store them in the capture property list."
-  (let ((target-entry-p t))
-    (save-excursion
-      (pcase (or target (org-capture-get :target))
-	(`here
-	 (org-capture-put :exact-position (point) :insert-here t))
-	(`(file ,path)
-	 (set-buffer (org-capture-target-buffer path))
-	 (org-capture-put-target-region-and-position)
-	 (widen)
-	 (setq target-entry-p nil))
-	(`(id ,id)
-	 (pcase (org-id-find id)
-	   (`(,path . ,position)
-	    (set-buffer (org-capture-target-buffer path))
-	    (widen)
-	    (org-capture-put-target-region-and-position)
-	    (goto-char position))
-	   (_ (error "Cannot find target ID \"%s\"" id))))
-	(`(file+headline ,path ,headline)
-	 (set-buffer (org-capture-target-buffer path))
-	 ;; Org expects the target file to be in Org mode, otherwise
-	 ;; it throws an error.  However, the default notes files
-	 ;; should work out of the box.  In this case, we switch it to
-	 ;; Org mode.
-	 (unless (derived-mode-p 'org-mode)
-	   (org-display-warning
-	    (format "Capture requirement: switching buffer %S to Org mode"
-		    (current-buffer)))
-	   (org-mode))
-	 (org-capture-put-target-region-and-position)
-	 (widen)
-	 (goto-char (point-min))
-	 (if (re-search-forward (format org-complex-heading-regexp-format
-					(regexp-quote headline))
-				nil t)
-	     (beginning-of-line)
-	   (goto-char (point-max))
-	   (unless (bolp) (insert "\n"))
-	   (insert "* " headline "\n")
-	   (beginning-of-line 0)))
-	(`(file+olp ,path . ,outline-path)
-	 (let ((m (org-find-olp (cons (org-capture-expand-file path)
-				      outline-path))))
-	   (set-buffer (marker-buffer m))
-	   (org-capture-put-target-region-and-position)
-	   (widen)
-	   (goto-char m)
-	   (set-marker m nil)))
-	(`(file+regexp ,path ,regexp)
-	 (set-buffer (org-capture-target-buffer path))
-	 (org-capture-put-target-region-and-position)
-	 (widen)
-	 (goto-char (point-min))
-	 (if (not (re-search-forward regexp nil t))
-	     (error "No match for target regexp in file %s" path)
-	   (goto-char (if (org-capture-get :prepend)
-			  (match-beginning 0)
-			(match-end 0)))
-	   (org-capture-put :exact-position (point))
-	   (setq target-entry-p
-		 (and (derived-mode-p 'org-mode) (org-at-heading-p)))))
-	(`(file+olp+datetree ,path . ,outline-path)
-	 (let ((m (if outline-path
-		      (org-find-olp (cons (org-capture-expand-file path)
-					  outline-path))
-		    (set-buffer (org-capture-target-buffer path))
-		    (point-marker))))
-	   (set-buffer (marker-buffer m))
-	   (org-capture-put-target-region-and-position)
-	   (widen)
-	   (goto-char m)
-	   (set-marker m nil)
-	   (require 'org-datetree)
-	   (org-capture-put-target-region-and-position)
-	   (widen)
-	   ;; Make a date/week tree entry, with the current date (or
-	   ;; yesterday, if we are extending dates for a couple of
-	   ;; hours)
-	   (funcall
-	    (pcase (org-capture-get :tree-type)
-	      (`week #'org-datetree-find-iso-week-create)
-	      (`month #'org-datetree-find-month-create)
-	      (_ #'org-datetree-find-date-create))
-	    (calendar-gregorian-from-absolute
-	     (cond
-	      (org-overriding-default-time
-	       ;; Use the overriding default time.
-	       (time-to-days org-overriding-default-time))
-	      ((or (org-capture-get :time-prompt)
-		   (equal current-prefix-arg 1))
-               ;; Prompt for date.  Bind `org-end-time-was-given' so
-               ;; that `org-read-date-analyze' handles the time range
-               ;; case and returns `prompt-time' with the start value.
-               (let* ((org-time-was-given nil)
-                      (org-end-time-was-given nil)
-                      (prompt-time (org-read-date
-				    nil t nil "Date for tree entry:")))
-		 (org-capture-put
-		  :default-time
-                  (if (or org-time-was-given
-                          (= (time-to-days prompt-time) (org-today)))
-                      prompt-time
-                    ;; Use 00:00 when no time is given for another
-                    ;; date than today?
-                    (apply #'encode-time 0 0
-                           org-extend-today-until
-                           (cl-cdddr (decode-time prompt-time)))))
-		 (time-to-days prompt-time)))
-	      (t
-	       ;; Current date, possibly corrected for late night
-	       ;; workers.
-	       (org-today))))
-	    ;; the following is the keep-restriction argument for
-	    ;; org-datetree-find-date-create
-	    (when outline-path 'subtree-at-point))))
-	(`(file+function ,path ,function)
-	 (set-buffer (org-capture-target-buffer path))
-	 (org-capture-put-target-region-and-position)
-	 (widen)
-	 (funcall function)
-	 (org-capture-put :exact-position (point))
-	 (setq target-entry-p
-	       (and (derived-mode-p 'org-mode) (org-at-heading-p))))
-	(`(function ,fun)
-	 (funcall fun)
-	 (org-capture-put :exact-position (point))
-	 (setq target-entry-p
-	       (and (derived-mode-p 'org-mode) (org-at-heading-p))))
-	(`(clock)
-	 (if (and (markerp org-clock-hd-marker)
-		  (marker-buffer org-clock-hd-marker))
-	     (progn (set-buffer (marker-buffer org-clock-hd-marker))
-		    (org-capture-put-target-region-and-position)
-		    (widen)
-		    (goto-char org-clock-hd-marker))
-	   (user-error "No running clock that could be used as capture target")))
-	(target (error "Invalid capture target specification: %S" target)))
-
-      (org-capture-put :buffer (current-buffer)
-		       :pos (point)
-		       :target-entry-p target-entry-p
-		       :decrypted
-		       (and (featurep 'org-crypt)
-			    (org-at-encrypted-entry-p)
-			    (save-excursion
-			      (org-decrypt-entry)
-			      (and (org-back-to-heading t) (point))))))))
-
-(defun org-capture-expand-file (file)
-  "Expand functions, symbols and file names for FILE.
-When FILE is a function, call it.  When it is a form, evaluate
-it.  When it is a variable, return its value.  When it is
-a string, treat it as a file name, possibly expanding it
-according to `org-directory', and return it.  If it is the empty
-string, however, return `org-default-notes-file'.  In any other
-case, raise an error."
-  (let ((location (cond ((equal file "") org-default-notes-file)
-			((stringp file) (expand-file-name file org-directory))
-			((functionp file) (funcall file))
-			((and (symbolp file) (boundp file)) (symbol-value file))
-			(t nil))))
-    (or (org-string-nw-p location)
-	(error "Invalid file location: %S" location))))
-
-(defun org-capture-target-buffer (file)
-  "Get a buffer for FILE.
-FILE is a generalized file location, as handled by
-`org-capture-expand-file'."
-  (let ((file (org-capture-expand-file file)))
-    (or (org-find-base-buffer-visiting file)
-	(progn (org-capture-put :new-buffer t)
-	       (find-file-noselect file)))))
-
-(defun org-capture-place-template (&optional inhibit-wconf-store)
-  "Insert the template at the target location, and display the buffer.
-When INHIBIT-WCONF-STORE is non-nil, don't store the window configuration, as it
-may have been stored before."
-  (unless inhibit-wconf-store
-    (org-capture-put :return-to-wconf (current-window-configuration)))
-  (delete-other-windows)
-  (org-switch-to-buffer-other-window
-   (org-capture-get-indirect-buffer (org-capture-get :buffer) "CAPTURE"))
-  (widen)
-  (org-show-all)
-  (goto-char (org-capture-get :pos))
-  (setq-local outline-level 'org-outline-level)
-  (pcase (org-capture-get :type)
-    ((or `nil `entry) (org-capture-place-entry))
-    (`table-line (org-capture-place-table-line))
-    (`plain (org-capture-place-plain-text))
-    (`item (org-capture-place-item))
-    (`checkitem (org-capture-place-item)))
-  (setq-local org-capture-current-plist org-capture-plist)
-  (org-capture-mode 1))
-
-(defun org-capture-place-entry ()
-  "Place the template as a new Org entry."
-  (let ((template (org-capture-get :template))
-	(reversed? (org-capture-get :prepend))
-	(exact-position (org-capture-get :exact-position))
-	(insert-here? (org-capture-get :insert-here))
-	(level 1))
-    (org-capture-verify-tree template)
-    (when exact-position (goto-char exact-position))
-    (cond
-     ;; Force insertion at point.
-     (insert-here?
-      ;; FIXME: level should probably set directly within (let ...).
-      (setq level (org-get-valid-level
-                   (if (or (org-at-heading-p)
-                           (ignore-errors
-			     (save-excursion (org-back-to-heading t))))
-                       (org-outline-level)
-                     1))))
-     ;; Insert as a child of the current entry.
-     ((org-capture-get :target-entry-p)
-      (setq level (org-get-valid-level
-		   (if (org-at-heading-p) (org-outline-level) 1)
-		   1))
-      (if reversed? (outline-next-heading) (org-end-of-subtree t t)))
-     ;; Insert as a top-level entry at the beginning of the file.
-     (reversed?
-      (goto-char (point-min))
-      (unless (org-at-heading-p) (outline-next-heading)))
-     ;; Otherwise, insert as a top-level entry at the end of the file.
-     (t (goto-char (point-max))))
-    (let ((origin (point)))
-      (unless (bolp) (insert "\n"))
-      (org-capture-empty-lines-before)
-      (let ((beg (point)))
-	(save-restriction
-	  (when insert-here? (narrow-to-region beg beg))
-	  (org-paste-subtree level template 'for-yank))
-	(org-capture-position-for-last-stored beg)
-	(org-capture-empty-lines-after)
-	(unless (org-at-heading-p) (outline-next-heading))
-	(org-capture-mark-kill-region origin (point))
-	(org-capture-narrow beg (if (eobp) (point) (1- (point))))
-	(org-capture--position-cursor beg (point))))))
-
-(defun org-capture-place-item ()
-  "Place the template as a new plain list item."
-  (let ((prepend? (org-capture-get :prepend))
-	(template (org-remove-indentation (org-capture-get :template)))
-	item)
-    ;; Make template suitable for insertion.  In particular, add
-    ;; a main bullet if it is missing.
-    (unless (string-match-p (concat "\\`" (org-item-re)) template)
-      (setq template (concat "- " (mapconcat #'identity
-					     (split-string template "\n")
-					     "\n  "))))
-    ;; Delimit the area where we should look for a plain list.
-    (pcase-let ((`(,beg . ,end)
-		 (cond ((org-capture-get :exact-position)
-			;; User gave a specific position.  Start
-			;; looking for lists from here.
-			(org-with-point-at (org-capture-get :exact-position)
-			  (cons (line-beginning-position)
-				(if (org-capture-get :insert-here)
-				    (line-beginning-position)
-				  (org-entry-end-position)))))
-		       ((org-capture-get :target-entry-p)
-			;; At a heading, limit search to its body.
-			(cons (line-beginning-position 2)
-			      (org-entry-end-position)))
-		       (t
-			;; Table is not necessarily under a heading.
-			;; Search whole buffer.
-			(cons (point-min) (point-max))))))
-      ;; Find the first plain list in the delimited area.
-      (goto-char beg)
-      (let ((item-regexp (org-item-beginning-re)))
-	(catch :found
-	  (while (re-search-forward item-regexp end t)
-	    (when (setq item (org-element-lineage
-			      (org-element-at-point) '(plain-list) t))
-	      (goto-char (org-element-property (if prepend? :post-affiliated
-						 :contents-end)
-					       item))
-	      (throw :found t)))
-	  ;; No list found.  Move to the location when to insert
-	  ;; template.  Skip planning info and properties drawers, if
-	  ;; any.
-	  (goto-char (cond ((org-capture-get :insert-here) beg)
-			   ((not prepend?) end)
-			   ((org-before-first-heading-p) beg)
-			   (t (max (save-excursion
-				     (org-end-of-meta-data)
-				     (point))
-				   beg)))))))
-    ;; Insert template.
-    (let ((origin (point)))
-      (unless (bolp) (insert "\n"))
-      ;; When a new list is created, always obey to `:empty-lines' and
-      ;; friends.
-      ;;
-      ;; When capturing in an existing list, do not change blank lines
-      ;; above or below the list; consider it to be a stable
-      ;; structure.  However, we can control how many blank lines
-      ;; separate items.  So obey to `:empty-lines' between items as
-      ;; long as it does not insert more than one empty line.  In the
-      ;; specific case of empty lines above, it means we only obey the
-      ;; parameter when appending an item.
-      (unless (and item prepend?)
-	(org-capture-empty-lines-before
-	 (and item
-	      (not prepend?)
-	      (min 1 (or (org-capture-get :empty-lines-before)
-			 (org-capture-get :empty-lines)
-			 0)))))
-      (org-capture-position-for-last-stored (point))
-      (let ((beg (line-beginning-position))
-	    (end (progn
-		   (insert (org-trim template) "\n")
-		   (point-marker))))
-	(when item
-	  (let ((i (save-excursion
-		     (goto-char (org-element-property :post-affiliated item))
-		     (current-indentation))))
-	    (save-excursion
-	      (goto-char beg)
-	      (save-excursion
-		(while (< (point) end)
-		  (indent-to i)
-		  (forward-line)))
-	      ;; Pre-pending an item could change the type of the list
-	      ;; if there is a mismatch.  In this situation,
-	      ;; prioritize the existing list.
-	      (when prepend?
-		(let ((ordered? (eq 'ordered (org-element-property :type item))))
-		  (when (org-xor ordered?
-				 (string-match-p "\\`[A-Za-z0-9]\\([.)]\\)"
-						 template))
-		    (org-cycle-list-bullet (if ordered? "1." "-")))))
-	      ;; Eventually repair the list for proper indentation and
-	      ;; bullets.
-	      (org-list-repair))))
-	;; Limit number of empty lines.  See above for details.
-	(unless (and item (not prepend?))
-	  (org-capture-empty-lines-after
-	   (and item
-		prepend?
-		(min 1 (or (org-capture-get :empty-lines-after)
-			   (org-capture-get :empty-lines)
-			   0)))))
-	(org-capture-mark-kill-region origin (point))
-	;; ITEM always end with a newline character.  Make sure we do
-	;; not narrow at the beginning of the next line, possibly
-	;; altering its structure (e.g., when it is a headline).
-	(org-capture-narrow beg (1- end))
-	(org-capture--position-cursor beg end)))))
-
-(defun org-capture-place-table-line ()
-  "Place the template as a table line."
-  (require 'org-table)
-  (let ((text
-	 (pcase (org-trim (org-capture-get :template))
-	   ((pred (string-match-p org-table-border-regexp))
-	    "| %?Bad template |")
-	   (text (concat text "\n"))))
-	(table-line-pos (org-capture-get :table-line-pos))
-	beg end)
-    (cond
-     ((org-capture-get :exact-position)
-      (org-with-point-at (org-capture-get :exact-position)
-	(setq beg (line-beginning-position))
-	(setq end (if (org-capture-get :insert-here) beg
-		    (org-entry-end-position)))))
-     ((not (org-capture-get :target-entry-p))
-      ;; Table is not necessarily under a heading.  Find first table
-      ;; in the buffer.
-      (setq beg (point-min) end (point-max)))
-     (t
-      ;; We are at a heading, limit search to the body.
-      (setq beg (line-beginning-position 2))
-      (setq end (save-excursion (outline-next-heading) (point)))))
-    (goto-char beg)
-    ;; Narrow to the table, possibly creating one if necessary.
-    (catch :found
-      (while (re-search-forward org-table-dataline-regexp end t)
-	(pcase (org-element-lineage (org-element-at-point) '(table) t)
-	  (`nil nil)
-	  ((pred (lambda (e) (eq 'table.el (org-element-property :type e))))
-	   nil)
-	  (table
-	   (goto-char (org-element-property :contents-end table))
-	   (narrow-to-region (org-element-property :post-affiliated table)
-			     (point))
-	   (throw :found t))))
-      ;; No table found.  Create it with an empty header.
-      (goto-char end)
-      (unless (bolp) (insert "\n"))
-      (let ((origin (point)))
-	(insert "|   |\n|---|\n")
-	(narrow-to-region origin (point))))
-    ;; In the current table, find the appropriate location for TEXT.
-    (cond
-     ((org-capture-get :insert-here) nil)
-     ((and table-line-pos
-	   (string-match "\\(I+\\)\\([-+][0-9]+\\)" table-line-pos))
-      (goto-char (point-min))
-      (let ((line
-	     (condition-case _
-		 (progn
-		   (save-match-data (org-table-analyze))
-		   (aref org-table-hlines
-			 (- (match-end 1) (match-beginning 1))))
-	       (error
-		(error "Invalid table line specification %S" table-line-pos))))
-	    (delta (string-to-number (match-string 2 table-line-pos))))
-	(forward-line (+ line delta (if (< delta 0) 0 -1)))
-	(forward-line)))		;insert below
-     ((org-capture-get :prepend)
-      (goto-char (point-min))
-      (cond
-       ((not (re-search-forward org-table-hline-regexp nil t)))
-       ((re-search-forward org-table-dataline-regexp nil t) (beginning-of-line))
-       (t (goto-char (org-table-end)))))
-     (t
-      (goto-char (org-table-end))))
-    ;; Insert text and position point according to template.
-    (let ((origin (point)))
-      (unless (bolp) (insert "\n"))
-      (let ((beg (point))
-	    (end (save-excursion
-		   (insert text)
-		   (point))))
-	(org-capture-position-for-last-stored 'table-line)
-	(org-capture-mark-kill-region origin end)
-	;; TEXT is guaranteed to end with a newline character.  Ignore
-	;; it when narrowing so as to not alter data on the next line.
-	(org-capture-narrow beg (1- end))
-	(org-capture--position-cursor beg (1- end))))))
-
-(defun org-capture-place-plain-text ()
-  "Place the template plainly.
-If the target locator points at an Org node, place the template into
-the text of the entry, before the first child.  If not, place the
-template at the beginning or end of the file.
-Of course, if exact position has been required, just put it there."
-  (cond
-   ((org-capture-get :exact-position)
-    (goto-char (org-capture-get :exact-position)))
-   ((org-capture-get :target-entry-p)
-    ;; Place the text into this entry.
-    (if (org-capture-get :prepend)
-	;; Skip meta data and drawers.
-	(org-end-of-meta-data t)
-      ;; Go to end of the entry text, before the next headline.
-      (outline-next-heading)))
-   (t
-    ;; Beginning or end of file.
-    (goto-char (if (org-capture-get :prepend) (point-min) (point-max)))))
-  (let ((origin (point)))
-    (unless (bolp) (insert "\n"))
-    (org-capture-empty-lines-before)
-    (org-capture-position-for-last-stored (point))
-    (let ((beg (point)))
-      (insert (org-capture-get :template))
-      (unless (bolp) (insert "\n"))
-      ;; Ignore the final newline character so as to not alter data
-      ;; after inserted text.  Yet, if the template is empty, make
-      ;; sure END matches BEG instead of pointing before it.
-      (let ((end (max beg (1- (point)))))
-	(org-capture-empty-lines-after)
-	(org-capture-mark-kill-region origin (point))
-	(org-capture-narrow beg end)
-	(org-capture--position-cursor beg end)))))
-
-(defun org-capture-mark-kill-region (beg end)
-  "Mark region between BEG and END to be killed on aborted capture."
-  (let ((m1 (copy-marker beg))
-	(m2 (copy-marker end t)))
-    (org-capture-put :begin-marker m1)
-    (org-capture-put :end-marker m2)))
-
-(defun org-capture-position-for-last-stored (position)
-  "Put POSITION on `org-capture-plist' for future use as `last capture`."
-  (cond
-   ((integerp position)
-    (org-capture-put :position-for-last-stored
-		     (move-marker (make-marker) position
-				  (or (buffer-base-buffer (current-buffer))
-				      (current-buffer)))))
-   ((eq position 'table-line)
-    (org-capture-put :position-for-last-stored
-		     (list 'table-line
-			   (org-table-current-dline))))
-   (t (error "This should not happen"))))
-
-(defun org-capture-store-last-position ()
-  "Store the last-captured position."
-  (let* ((where (org-capture-get :position-for-last-stored 'local))
-	 (pos (cond
-	       ((markerp where)
-		(prog1 (marker-position where)
-		  (move-marker where nil)))
-	       ((and (listp where) (eq (car where) 'table-line))
-		(if (org-at-table-p)
-		    (save-excursion
-		      (org-table-goto-line (nth 1 where))
-		      (point-at-bol))
-		  (point))))))
-    (with-current-buffer (buffer-base-buffer (current-buffer))
-      (org-with-point-at pos
-	(when org-capture-bookmark
-	  (let ((bookmark (plist-get org-bookmark-names-plist :last-capture)))
-	    (when bookmark (with-demoted-errors (bookmark-set bookmark)))))
-	(move-marker org-capture-last-stored-marker (point))))))
-
-(defun org-capture-narrow (beg end)
-  "Possibly narrow to region between BEG and END.
-If configuration contains non-nil :unnarrowed property, do not narrow."
-  (unless (org-capture-get :unnarrowed)
-    (narrow-to-region beg end)))
-
-(defun org-capture--position-cursor (beg end)
-  "Move point to first \"%?\" location or at start of template.
-BEG and END are buffer positions at the beginning and end position
-of the template."
-  (goto-char beg)
-  (when (search-forward "%?" end t)
-    (replace-match "")))
-
-(defun org-capture-empty-lines-before (&optional n)
-  "Insert N empty lines before the insertion point.
-Point will be after the empty lines, so insertion can directly be done.
-If N is nil, :empty-lines-before or :empty-lines are considered."
-  (setq n (or n (org-capture-get :empty-lines-before)
-	      (org-capture-get :empty-lines) 0))
-  (let ((pos (point)))
-    (org-back-over-empty-lines)
-    (delete-region (point) pos)
-    (when (> n 0) (newline n))))
-
-(defun org-capture-empty-lines-after (&optional n)
-  "Set the correct number of empty lines after the inserted string.
-Point will remain at the first line after the inserted text.
-If N is nil, :empty-lines-after or :empty-lines are considered."
-  (setq n (or n (org-capture-get :empty-lines-after)
-	      (org-capture-get :empty-lines) 0))
-  (org-back-over-empty-lines)
-  (while (looking-at "[ \t]*\n") (replace-match ""))
-  (let ((pos (point)))
-    (when (> n 0) (newline n))
-    (goto-char pos)))
-
-(defvar org-clock-marker) ; Defined in org.el
-
-(defun org-capture-set-plist (entry)
-  "Initialize the property list for ENTRY from the template definition."
-  (setq org-capture-plist (copy-sequence (nthcdr 5 entry)))
-  (org-capture-put :key (car entry) :description (nth 1 entry)
-		   :target (nth 3 entry))
-  (let ((txt (nth 4 entry)) (type (or (nth 2 entry) 'entry)))
-    (when (or (not txt) (and (stringp txt) (not (string-match "\\S-" txt))))
-      ;; The template may be empty or omitted for special types.
-      ;; Here we insert the default templates for such cases.
-      (cond
-       ((eq type 'item) (setq txt "- %?"))
-       ((eq type 'checkitem) (setq txt "- [ ] %?"))
-       ((eq type 'table-line) (setq txt "| %? |"))
-       ((member type '(nil entry)) (setq txt "* %?\n  %a"))))
-    (org-capture-put :template txt :type type)))
-
-(defun org-capture-goto-target (&optional template-key)
-  "Go to the target location of a capture template.
-If TEMPLATE-KEY is nil, the user is queried for the template."
-  (interactive)
-  (let ((entry (org-capture-select-template template-key)))
-    (unless entry (error "No capture template selected"))
-    (org-capture-set-plist entry)
-    (org-capture-set-target-location)
-    (pop-to-buffer-same-window (org-capture-get :buffer))
-    (goto-char (org-capture-get :pos))))
-
-(defun org-capture-get-indirect-buffer (&optional buffer prefix)
-  "Make an indirect BUFFER for a capture process.
-Use PREFIX as a prefix for the name of the indirect buffer."
-  (setq buffer (or buffer (current-buffer)))
-  (let ((n 1) (base (buffer-name buffer)) bname)
-    (setq bname (concat prefix "-" base))
-    (while (buffer-live-p (get-buffer bname))
-      (setq bname (concat prefix "-" (number-to-string (cl-incf n)) "-" base)))
-    (condition-case nil
-        (make-indirect-buffer buffer bname 'clone)
-      (error
-       (let ((buf (make-indirect-buffer buffer bname)))
-	 (with-current-buffer buf (org-mode))
-	 buf)))))
-
-(defun org-capture-verify-tree (tree)
-  "Throw error if TREE is not a valid tree."
-  (unless (org-kill-is-subtree-p tree)
-    (error "Template is not a valid Org entry or tree")))
-
-;;; The template code
-(defun org-capture-select-template (&optional keys)
-  "Select a capture template.
-Lisp programs can force the template by setting KEYS to a string."
-  (let ((org-capture-templates
-	 (or (org-contextualize-keys
-	      (org-capture-upgrade-templates org-capture-templates)
-	      org-capture-templates-contexts)
-	     '(("t" "Task" entry (file+headline "" "Tasks")
-		"* TODO %?\n  %u\n  %a")))))
-    (if keys
-	(or (assoc keys org-capture-templates)
-	    (error "No capture template referred to by \"%s\" keys" keys))
-      (org-mks org-capture-templates
-	       "Select a capture template\n========================="
-	       "Template key: "
-	       '(("C" "Customize org-capture-templates")
-		 ("q" "Abort"))))))
-
-(defvar org-capture--clipboards nil
-  "List various clipboards values.")
-
-(defun org-capture-fill-template (&optional template initial annotation)
-  "Fill a TEMPLATE and return the filled template as a string.
-The template may still contain \"%?\" for cursor positioning.
-INITIAL content and/or ANNOTATION may be specified, but will be overridden
-by their respective `org-store-link-plist' properties if present."
-  (let* ((template (or template (org-capture-get :template)))
-	 (buffer (org-capture-get :buffer))
-	 (file (buffer-file-name (or (buffer-base-buffer buffer) buffer)))
-	 (time (let* ((c (or (org-capture-get :default-time) (current-time)))
-		      (d (decode-time c)))
-		 (if (< (nth 2 d) org-extend-today-until)
-		     (encode-time 0 59 23 (1- (nth 3 d)) (nth 4 d) (nth 5 d))
-		   c)))
-	 (v-t (format-time-string (org-time-stamp-format nil) time))
-	 (v-T (format-time-string (org-time-stamp-format t) time))
-	 (v-u (format-time-string (org-time-stamp-format nil t) time))
-	 (v-U (format-time-string (org-time-stamp-format t t) time))
-	 (v-c (and kill-ring (current-kill 0)))
-	 (v-x (or (org-get-x-clipboard 'PRIMARY)
-		  (org-get-x-clipboard 'CLIPBOARD)
-		  (org-get-x-clipboard 'SECONDARY)
-		  ""))			;ensure it is a string
-	 ;; `initial' and `annotation' might have been passed.  But if
-	 ;; the property list has them, we prefer those values.
-	 (v-i (or (plist-get org-store-link-plist :initial)
-		  (and (stringp initial) (org-no-properties initial))
-		  (org-capture-get :initial)
-		  ""))
-	 (v-a
-	  (let ((a (or (plist-get org-store-link-plist :annotation)
-		       annotation
-		       (org-capture-get :annotation)
-		       "")))
-	    ;; Is the link empty?  Then we do not want it...
-	    (if (equal a "[[]]") "" a)))
-	 (l-re "\\[\\[\\(.*?\\)\\]\\(\\[.*?\\]\\)?\\]")
-	 (v-A (if (and v-a (string-match l-re v-a))
-		  (replace-match "[[\\1][%^{Link description}]]" nil nil v-a)
-		v-a))
-	 (v-l (if (and v-a (string-match l-re v-a))
-		  (replace-match "[[\\1]]" nil nil v-a)
-		v-a))
-	 (v-L (if (and v-a (string-match l-re v-a))
-		  (replace-match "\\1" nil nil v-a)
-		v-a))
-	 (v-n user-full-name)
-	 (v-k (if (marker-buffer org-clock-marker)
-		  (org-no-properties org-clock-heading)
-		""))
-	 (v-K (if (marker-buffer org-clock-marker)
-		  (org-link-make-string
-		   (format "%s::*%s"
-			   (buffer-file-name (marker-buffer org-clock-marker))
-			   v-k)
-		   v-k)
-		""))
-	 (v-f (or (org-capture-get :original-file-nondirectory) ""))
-	 (v-F (or (org-capture-get :original-file) ""))
-	 (org-capture--clipboards
-	  (delq nil
-		(list v-i
-		      (org-get-x-clipboard 'PRIMARY)
-		      (org-get-x-clipboard 'CLIPBOARD)
-		      (org-get-x-clipboard 'SECONDARY)
-		      v-c))))
-    (setq org-store-link-plist (plist-put org-store-link-plist :annotation v-a))
-    (setq org-store-link-plist (plist-put org-store-link-plist :initial v-i))
-    (unless template
-      (setq template "")
-      (message "no template") (ding)
-      (sit-for 1))
-    (save-window-excursion
-      (org-switch-to-buffer-other-window (get-buffer-create "*Capture*"))
-      (erase-buffer)
-      (setq buffer-file-name nil)
-      (setq mark-active nil)
-      (insert template)
-      (goto-char (point-min))
-      ;; %[] insert contents of a file.
-      (save-excursion
-	(while (re-search-forward "%\\[\\(.+\\)\\]" nil t)
-	  (let ((filename (expand-file-name (match-string 1)))
-		(beg (copy-marker (match-beginning 0)))
-		(end (copy-marker (match-end 0))))
-	    (unless (org-capture-escaped-%)
-	      (delete-region beg end)
-	      (set-marker beg nil)
-	      (set-marker end nil)
-	      (condition-case error
-		  (insert-file-contents filename)
-		(error
-		 (insert (format "%%![couldn not insert %s: %s]"
-				 filename
-				 error))))))))
-      ;; Mark %() embedded elisp for later evaluation.
-      (org-capture-expand-embedded-elisp 'mark)
-      ;; Expand non-interactive templates.
-      (let ((regexp "%\\(:[-A-Za-z]+\\|<\\([^>\n]+\\)>\\|[aAcfFikKlLntTuUx]\\)"))
-	(save-excursion
-	  (while (re-search-forward regexp nil t)
-	    ;; `org-capture-escaped-%' may modify buffer and cripple
-	    ;; match-data.  Use markers instead.  Ditto for other
-	    ;; templates.
-	    (let ((pos (copy-marker (match-beginning 0)))
-		  (end (copy-marker (match-end 0)))
-		  (value (match-string 1))
-		  (time-string (match-string 2)))
-	      (unless (org-capture-escaped-%)
-		(delete-region pos end)
-		(set-marker pos nil)
-		(set-marker end nil)
-		(let* ((inside-sexp? (org-capture-inside-embedded-elisp-p))
-		       (replacement
-			(pcase (string-to-char value)
-			  (?< (format-time-string time-string time))
-			  (?:
-			   (or (plist-get org-store-link-plist (intern value))
-			       ""))
-			  (?i
-			   (if inside-sexp? v-i
-			     ;; Outside embedded Lisp, repeat leading
-			     ;; characters before initial place holder
-			     ;; every line.
-			     (let ((lead (concat "\n"
-						 (org-current-line-string t))))
-			       (replace-regexp-in-string "\n" lead v-i nil t))))
-			  (?a v-a)
-			  (?A v-A)
-			  (?c v-c)
-			  (?f v-f)
-			  (?F v-F)
-			  (?k v-k)
-			  (?K v-K)
-			  (?l v-l)
-			  (?L v-L)
-			  (?n v-n)
-			  (?t v-t)
-			  (?T v-T)
-			  (?u v-u)
-			  (?U v-U)
-			  (?x v-x))))
-		  (insert
-		   (if inside-sexp?
-		       ;; Escape sensitive characters.
-		       (replace-regexp-in-string "[\\\"]" "\\\\\\&" replacement)
-		     replacement))))))))
-      ;; Expand %() embedded Elisp.  Limit to Sexp originally marked.
-      (org-capture-expand-embedded-elisp)
-      ;; Expand interactive templates.  This is the last step so that
-      ;; template is mostly expanded when prompting happens.  Turn on
-      ;; Org mode and set local variables.  This is to support
-      ;; completion in interactive prompts.
-      (let ((org-inhibit-startup t)) (org-mode))
-      (org-clone-local-variables buffer "\\`org-")
-      (let (strings)			; Stores interactive answers.
-	(save-excursion
-	  (let ((regexp "%\\^\\(?:{\\([^}]*\\)}\\)?\\([CgGLptTuU]\\)?"))
-	    (while (re-search-forward regexp nil t)
-	      (let* ((items (and (match-end 1)
-				 (save-match-data
-				   (split-string (match-string-no-properties 1)
-						 "|"))))
-		     (key (match-string 2))
-		     (beg (copy-marker (match-beginning 0)))
-		     (end (copy-marker (match-end 0)))
-		     (prompt (nth 0 items))
-		     (default (nth 1 items))
-		     (completions (nthcdr 2 items)))
-		(unless (org-capture-escaped-%)
-		  (delete-region beg end)
-		  (set-marker beg nil)
-		  (set-marker end nil)
-		  (pcase key
-		    ((or "G" "g")
-		     (let* ((org-last-tags-completion-table
-			     (org-global-tags-completion-table
-			      (cond ((equal key "G") (org-agenda-files))
-				    (file (list file))
-				    (t nil))))
-			    (org-add-colon-after-tag-completion t)
-			    (ins (mapconcat
-				  #'identity
-				  (let ((crm-separator "[ \t]*:[ \t]*"))
-                                    (completing-read-multiple
-				     (if prompt (concat prompt ": ") "Tags: ")
-				     org-last-tags-completion-table nil nil nil
-				     'org-tags-history))
-				  ":")))
-		       (when (org-string-nw-p ins)
-			 (unless (eq (char-before) ?:) (insert ":"))
-			 (insert ins)
-			 (unless (eq (char-after) ?:) (insert ":"))
-			 (when (org-at-heading-p) (org-align-tags)))))
-		    ((or "C" "L")
-		     (let ((insert-fun (if (equal key "C") #'insert
-					 (lambda (s) (org-insert-link 0 s)))))
-		       (pcase org-capture--clipboards
-			 (`nil nil)
-			 (`(,value) (funcall insert-fun value))
-			 (`(,first-value . ,_)
-			  (funcall insert-fun
-				   (read-string "Clipboard/kill value: "
-						first-value
-						'org-capture--clipboards
-						first-value)))
-			 (_ (error "Invalid `org-capture--clipboards' value: %S"
-				   org-capture--clipboards)))))
-		    ("p"
-		     ;; We remove keyword properties inherited from
-		     ;; target buffer so `org-read-property-value' has
-		     ;; a chance to find allowed values in sub-trees
-		     ;; from the target buffer.
-		     (setq-local org-keyword-properties nil)
-		     (let* ((origin (set-marker (make-marker)
-						(org-capture-get :pos)
-						(org-capture-get :buffer)))
-			    ;; Find location from where to get allowed
-			    ;; values.  If `:target-entry-p' is
-			    ;; non-nil, the current headline in the
-			    ;; target buffer is going to be a parent
-			    ;; headline, so location is fine.
-			    ;; Otherwise, find the parent headline in
-			    ;; the target buffer.
-			    (pom (if (org-capture-get :target-entry-p) origin
-				   (let ((level (progn
-						  (while (org-up-heading-safe))
-						  (org-current-level))))
-				     (org-with-point-at origin
-				       (let ((l (if (org-at-heading-p)
-						    (org-current-level)
-						  most-positive-fixnum)))
-					 (while (and l (>= l level))
-					   (setq l (org-up-heading-safe)))
-					 (if l (point-marker)
-					   (point-min-marker)))))))
-			    (value
-			     (org-read-property-value prompt pom default)))
-		       (org-set-property prompt value)))
-		    ((or "t" "T" "u" "U")
-		     ;; These are the date/time related ones.
-		     (let* ((upcase? (equal (upcase key) key))
-			    (org-end-time-was-given nil)
-			    (time (org-read-date upcase? t nil prompt)))
-		       (org-insert-time-stamp
-			time (or org-time-was-given upcase?)
-			(member key '("u" "U"))
-			nil nil (list org-end-time-was-given))))
-		    (`nil
-		     ;; Load history list for current prompt.
-		     (setq org-capture--prompt-history
-			   (gethash prompt org-capture--prompt-history-table))
-		     (push (org-completing-read
-			    (concat (or prompt "Enter string")
-				    (and default (format " [%s]" default))
-				    ": ")
-			    completions
-			    nil nil nil 'org-capture--prompt-history default)
-			   strings)
-		     (insert (car strings))
-		     ;; Save updated history list for current prompt.
-		     (puthash prompt org-capture--prompt-history
-			      org-capture--prompt-history-table))
-		    (_
-		     (error "Unknown template placeholder: \"%%^%s\""
-			    key))))))))
-	;; Replace %n escapes with nth %^{...} string.
-	(setq strings (nreverse strings))
-	(save-excursion
-	  (while (re-search-forward "%\\\\\\([1-9][0-9]*\\)" nil t)
-	    (unless (org-capture-escaped-%)
-	      (replace-match
-	       (nth (1- (string-to-number (match-string 1))) strings)
-	       nil t)))))
-      ;; Make sure there are no empty lines before the text, and that
-      ;; it ends with a newline character or it is empty.
-      (skip-chars-forward " \t\n")
-      (delete-region (point-min) (line-beginning-position))
-      (goto-char (point-max))
-      (skip-chars-backward " \t\n")
-      (if (bobp) (delete-region (point) (line-end-position))
-	(end-of-line)
-	(delete-region (point) (point-max))
-	(insert "\n"))
-      ;; Return the expanded template and kill the capture buffer.
-      (untabify (point-min) (point-max))
-      (set-buffer-modified-p nil)
-      (prog1 (buffer-substring-no-properties (point-min) (point-max))
-	(kill-buffer (current-buffer))))))
-
-(defun org-capture-escaped-% ()
-  "Non-nil if % was escaped.
-If yes, unescape it now.  Assume `match-data' contains the
-placeholder to check."
-  (save-excursion
-    (goto-char (match-beginning 0))
-    (let ((n (abs (skip-chars-backward "\\\\"))))
-      (delete-char (/ (1+ n) 2))
-      (= (% n 2) 1))))
-
-(defun org-capture-expand-embedded-elisp (&optional mark)
-  "Evaluate embedded elisp %(sexp) and replace with the result.
-When optional MARK argument is non-nil, mark Sexp with a text
-property (`org-embedded-elisp') for later evaluation.  Only
-marked Sexp are evaluated when this argument is nil."
-  (save-excursion
-    (goto-char (point-min))
-    (while (re-search-forward "%(" nil t)
-      (cond
-       ((get-text-property (match-beginning 0) 'org-embedded-elisp)
-	(goto-char (match-beginning 0))
-	(let ((template-start (point)))
-	  (forward-char 1)
-	  (let* ((sexp (read (current-buffer)))
-		 (result (org-eval
-			  (org-capture--expand-keyword-in-embedded-elisp
-			   sexp))))
-	    (delete-region template-start (point))
-	    (cond
-	     ((not result) nil)
-	     ((stringp result) (insert result))
-	     (t (error
-		 "Capture template sexp `%s' must evaluate to string or nil"
-		 sexp))))))
-       ((not mark) nil)
-       ;; Only mark valid and non-escaped sexp.
-       ((org-capture-escaped-%) nil)
-       (t
-	(let ((end (with-syntax-table emacs-lisp-mode-syntax-table
-		     (ignore-errors (scan-sexps (1- (point)) 1)))))
-	  (when end
-	    (put-text-property (- (point) 2) end 'org-embedded-elisp t))))))))
-
-(defun org-capture--expand-keyword-in-embedded-elisp (attr)
-  "Recursively replace capture link keywords in ATTR sexp.
-Such keywords are prefixed with \"%:\".  See
-`org-capture-template' for more information."
-  (cond ((consp attr)
-	 (mapcar 'org-capture--expand-keyword-in-embedded-elisp attr))
-	((symbolp attr)
-	 (let* ((attr-symbol (symbol-name attr))
-		(key (and (string-match "%\\(:.*\\)" attr-symbol)
-			  (intern (match-string 1 attr-symbol)))))
-	   (or (plist-get org-store-link-plist key)
-	       attr)))
-	(t attr)))
-
-(defun org-capture-inside-embedded-elisp-p ()
-  "Non-nil if point is inside of embedded elisp %(sexp).
-Assume sexps have been marked with
-`org-capture-expand-embedded-elisp' beforehand."
-  (get-text-property (point) 'org-embedded-elisp))
-
-;;;###autoload
-(defun org-capture-import-remember-templates ()
-  "Set `org-capture-templates' to be similar to `org-remember-templates'."
-  (interactive)
-  (when (and (yes-or-no-p
-	      "Import old remember templates into org-capture-templates? ")
-	     (yes-or-no-p
-	      "Note that this will remove any templates currently defined in `org-capture-templates'.  Do you still want to go ahead? "))
-    (require 'org-remember)
-    (setq org-capture-templates
-	  (mapcar
-	   (lambda (entry)
-	     (let ((desc (car entry))
-		   (key (char-to-string (nth 1 entry)))
-		   (template (nth 2 entry))
-		   (file (or (nth 3 entry) org-default-notes-file))
-		   (position (or (nth 4 entry) org-remember-default-headline))
-		   (type 'entry)
-		   (prepend org-reverse-note-order)
-		   immediate target jump-to-captured)
-	       (cond
-		((member position '(top bottom))
-		 (setq target (list 'file file)
-		       prepend (eq position 'top)))
-		((eq position 'date-tree)
-		 (setq target (list 'file+datetree file)
-		       prepend nil))
-		(t (setq target (list 'file+headline file position))))
-
-	       (when (string-match "%!" template)
-		 (setq template (replace-match "" t t template)
-		       immediate t))
-
-	       (when (string-match "%&" template)
-		 (setq jump-to-captured t))
-
-	       (append (list key desc type target template)
-		       (and prepend '(:prepend t))
-		       (and immediate '(:immediate-finish t))
-		       (and jump-to-captured '(:jump-to-captured t)))))
-
-	   org-remember-templates))))
-
-
-(provide 'org-capture)
-
-;;; org-capture.el ends here