---END PERSONAL NOPUSH DIVIDER---

--
2.42.0

doc/org-manual.org

@@ -3300,10 +3300,6 @@ Here is the full set of built-in link types:
 
   File links.  File name may be remote, absolute, or relative.
 
-  Additionally, you can specify a line number, or a text search.
-  In Org files, you may link to a headline name, a custom ID, or a
-  code reference instead.
-
   As a special case, "file" prefix may be omitted if the file name
   is complete, e.g., it starts with =./=, or =/=.
 
@@ -3367,44 +3363,50 @@ Here is the full set of built-in link types:
 
   Execute a shell command upon activation.
 
+
+For =file:= and =id:= links, you can additionally specify a line
+number, or a text search string, separated by =::=.  In Org files, you
+may link to a headline name, a custom ID, or a code reference instead.
+
 The following table illustrates the link types above, along with their
 options:
 
-| Link Type  | Example                                                  |
-|------------+----------------------------------------------------------|
-| http       | =http://staff.science.uva.nl/c.dominik/=                 |
-| https      | =https://orgmode.org/=                                   |
-| doi        | =doi:10.1000/182=                                        |
-| file       | =file:/home/dominik/images/jupiter.jpg=                  |
-|            | =/home/dominik/images/jupiter.jpg= (same as above)       |
-|            | =file:papers/last.pdf=                                   |
-|            | =./papers/last.pdf= (same as above)                      |
-|            | =file:/ssh:me@some.where:papers/last.pdf= (remote)       |
-|            | =/ssh:me@some.where:papers/last.pdf= (same as above)     |
-|            | =file:sometextfile::NNN= (jump to line number)           |
-|            | =file:projects.org=                                      |
-|            | =file:projects.org::some words= (text search)[fn:12]     |
-|            | =file:projects.org::*task title= (headline search)       |
-|            | =file:projects.org::#custom-id= (headline search)        |
-| attachment | =attachment:projects.org=                                |
-|            | =attachment:projects.org::some words= (text search)      |
-| docview    | =docview:papers/last.pdf::NNN=                           |
-| id         | =id:B7423F4D-2E8A-471B-8810-C40F074717E9=                |
-| news       | =news:comp.emacs=                                        |
-| mailto     | =mailto:adent@galaxy.net=                                |
-| mhe        | =mhe:folder= (folder link)                               |
-|            | =mhe:folder#id= (message link)                           |
-| rmail      | =rmail:folder= (folder link)                             |
-|            | =rmail:folder#id= (message link)                         |
-| gnus       | =gnus:group= (group link)                                |
-|            | =gnus:group#id= (article link)                           |
-| bbdb       | =bbdb:R.*Stallman= (record with regexp)                  |
-| irc        | =irc:/irc.com/#emacs/bob=                                |
-| help       | =help:org-store-link=                                    |
-| info       | =info:org#External links=                                |
-| shell      | =shell:ls *.org=                                         |
-| elisp      | =elisp:(find-file "Elisp.org")= (Elisp form to evaluate) |
-|            | =elisp:org-agenda= (interactive Elisp command)           |
+| Link Type  | Example                                                            |
+|------------+--------------------------------------------------------------------|
+| http       | =http://staff.science.uva.nl/c.dominik/=                           |
+| https      | =https://orgmode.org/=                                             |
+| doi        | =doi:10.1000/182=                                                  |
+| file       | =file:/home/dominik/images/jupiter.jpg=                            |
+|            | =/home/dominik/images/jupiter.jpg= (same as above)                 |
+|            | =file:papers/last.pdf=                                             |
+|            | =./papers/last.pdf= (same as above)                                |
+|            | =file:/ssh:me@some.where:papers/last.pdf= (remote)                 |
+|            | =/ssh:me@some.where:papers/last.pdf= (same as above)               |
+|            | =file:sometextfile::NNN= (jump to line number)                     |
+|            | =file:projects.org=                                                |
+|            | =file:projects.org::some words= (text search)[fn:12]               |
+|            | =file:projects.org::*task title= (headline search)                 |
+|            | =file:projects.org::#custom-id= (headline search)                  |
+| attachment | =attachment:projects.org=                                          |
+|            | =attachment:projects.org::some words= (text search)                |
+| docview    | =docview:papers/last.pdf::NNN=                                     |
+| id         | =id:B7423F4D-2E8A-471B-8810-C40F074717E9=                          |
+|            | =id:B7423F4D-2E8A-471B-8810-C40F074717E9::*task= (headline search) |
+| news       | =news:comp.emacs=                                                  |
+| mailto     | =mailto:adent@galaxy.net=                                          |
+| mhe        | =mhe:folder= (folder link)                                         |
+|            | =mhe:folder#id= (message link)                                     |
+| rmail      | =rmail:folder= (folder link)                                       |
+|            | =rmail:folder#id= (message link)                                   |
+| gnus       | =gnus:group= (group link)                                          |
+|            | =gnus:group#id= (article link)                                     |
+| bbdb       | =bbdb:R.*Stallman= (record with regexp)                            |
+| irc        | =irc:/irc.com/#emacs/bob=                                          |
+| help       | =help:org-store-link=                                              |
+| info       | =info:org#External links=                                          |
+| shell      | =shell:ls *.org=                                                   |
+| elisp      | =elisp:(find-file "Elisp.org")= (Elisp form to evaluate)           |
+|            | =elisp:org-agenda= (interactive Elisp command)                     |
 
 #+cindex: VM links
 #+cindex: Wanderlust links
@@ -3465,8 +3467,9 @@ current buffer:
 - /Org mode buffers/ ::
 
   For Org files, if there is a =<<target>>= at point, the link points
-  to the target.  Otherwise it points to the current headline, which
-  is also the description.
+  to the target.  If there is a named block (using =#+name:=) at
+  point, the link points to that name.  Otherwise it points to the
+  current headline, which is also the description.
 
   #+vindex: org-id-link-to-org-use-id
   #+cindex: @samp{CUSTOM_ID}, property
@@ -3484,6 +3487,32 @@ current buffer:
   timestamp, depending on ~org-id-method~.  Later, when inserting the
   link, you need to decide which one to use.
 
+  #+vindex: org-id-link-consider-parent-id
+  #+vindex: org-id-link-use-context
+  #+vindex: org-link-context-for-files
+  When ~org-id-link-consider-parent-id~ is ~t~[fn:: Also,
+ ~org-link-context-for-files~ and ~org-id-link-use-context~ should be
+  both enabled (which they are, by default).], parent =ID= properties
+  are considered.  This allows linking to specific targets, named
+  blocks, or headlines (which may not have a globally unique =ID=
+  themselves) within the context of a parent headline or file which
+  does.
+
+  For example, given this org file:
+
+  #+begin_src org
+  ,* Parent
+  :PROPERTIES:
+  :ID: abc
+  :END:
+  ,** Child 1
+  ,** Child 2
+  #+end_src
+
+  Storing a link with point at "Child 1" will produce a link
+ =<id:abc::*Child 1>=, which precisely links to the "Child 1"
+  headline even though it does not have its own ID.
+
 - /Email/News clients: VM, Rmail, Wanderlust, MH-E, Gnus/ ::
 
   #+vindex: org-link-email-description-format
@@ -3763,7 +3792,9 @@ the link completion function like this:
 :ALT_TITLE: Search Options
 :END:
 #+cindex: search option in file links
+#+cindex: search option in id links
 #+cindex: file links, searching
+#+cindex: id links, searching
 #+cindex: attachment links, searching
 
 File links can contain additional information to make Emacs jump to a
@@ -3775,8 +3806,8 @@ example, when the command ~org-store-link~ creates a link (see
 line as a search string that can be used to find this line back later
 when following the link with {{{kbd(C-c C-o)}}}.
 
-Note that all search options apply for Attachment links in the same
-way that they apply for File links.
+Note that all search options apply for Attachment and ID links in the
+same way that they apply for File links.
 
 Here is the syntax of the different ways to attach a search to a file
 link, together with explanations for each:
@@ -12544,7 +12575,7 @@ Inclusions may specify a file-link to extract an object matched by
 ranges for =:lines= keyword are relative to the requested element.
 Therefore,
 
-: #+INCLUDE: "./paper.org::*conclusion" :lines 1-20
+: #+INCLUDE: "./paper.org::*conclusion" :lines "1-20"
 
 #+texinfo: @noindent
 includes the first 20 lines of the headline named =conclusion=.
@@ -18479,9 +18510,9 @@ Here are examples of passing values by reference:
   names---because the second row is a horizontal rule---then Org
   removes the column names, processes the table, puts back the column
   names, and then writes the table to the results block.  Using =yes=,
-  Org does the same to the first row, even if the initial table does
-  not contain any horizontal rule.  When set to =no=, Org does not
-  pre-process column names at all.
+  Org does the same to the first non-hline row, even if the initial
+  table does not contain any horizontal rule.  When set to =no=, Org
+  does not pre-process column names at all.
 
   # We keep python blocks unindented on purpose - to keep the example
   # working even for users who changed the default value of ~org-src-preserve-indentation~
@@ -21911,7 +21942,7 @@ The following =ol-man.el= file implements it
 PATH should be a topic that can be thrown at the man command."
   (funcall org-man-command path))
 
-(defun org-man-store-link ()
+(defun org-man-store-link (&optional _interactive?)
   "Store a link to a man page."
   (when (memq major-mode '(Man-mode woman-mode))
     ;; This is a man page, we do make this link.
@@ -21971,13 +22002,15 @@ A review of =ol-man.el=:
 
    For example, ~org-man-store-link~ is responsible for storing a link
    when ~org-store-link~ (see [[*Handling Links]]) is called from a buffer
-   displaying a man page.  It first checks if the major mode is
-   appropriate.  If check fails, the function returns ~nil~, which
-   means it isn't responsible for creating a link to the current
-   buffer.  Otherwise the function makes a link string by combining
-   the =man:= prefix with the man topic.  It also provides a default
-   description.  The function ~org-insert-link~ can insert it back
-   into an Org buffer later on.
+   displaying a man page.  It is passed an argument ~interactive?~
+   which this function does not use, but other store functions use to
+   behave differently when a link is stored interactively by the user.
+   It first checks if the major mode is appropriate.  If check fails,
+   the function returns ~nil~, which means it isn't responsible for
+   creating a link to the current buffer.  Otherwise the function
+   makes a link string by combining the =man:= prefix with the man
+   topic.  It also provides a default description.  The function
+ ~org-insert-link~ can insert it back into an Org buffer later on.
 
 ** Adding Export Backends
 :PROPERTIES:

etc/ORG-NEWS

@@ -460,6 +460,14 @@ timestamp object.  Possible values: ~timerange~, ~daterange~, ~nil~.
 ~org-element-timestamp-interpreter~ takes into account this property
 and returns an appropriate timestamp string.
 
+**** =org-link= store functions are passed an ~interactive?~ argument
+
+The ~:store:~ functions set for link types using
+~org-link-set-parameters~ are now passed an ~interactive?~ argument,
+indicating whether ~org-store-link~ was called interactively.
+
+Existing store functions will continue to work.
+
 *** ~org-priority=show~ command no longer adjusts for scheduled/deadline
 
 In agenda views, ~org-priority=show~ command previously displayed the
@@ -689,7 +697,45 @@ The change is breaking when ~org-use-property-inheritance~ is set to ~t~.
 *** ~org-babel-lilypond-compile-lilyfile~ ignores optional second argument
 
 The =TEST= parameter is better served by Emacs debugging tools.
+
+*** =id:= links support search options; ~org-id-store-link~ adds search option by default
+
+Adding search option by ~org-id-store-link~ can be disabled by setting
+~org-id-link-use-context~ to ~nil~, or toggled for a single call by
+passing universal argument.
+
+When using this feature, IDs should not include =::=, which is used in
+links to indicate the start of the search string.  For backwards
+compability, existing IDs including =::= will still be matched (but
+cannot be used together with search option).  A new org-lint checker
+has been added to warn about this.
+
+*** ~org-store-link~ behaviour storing additional =CUSTOM_ID= links has changed
+
+Previously, when storing =id:= link, ~org-store-link~ stored an
+additional "human readable" link using a node's =CUSTOM_ID= property.
+
+This behaviour has been expanded to store an additional =CUSTOM_ID=
+link when storing any type of external link type in an Org file, not
+just =id:= links.
+
 ** New and changed options
+*** New option ~org-beamer-frame-environment~
+
+The new option defines name of an alternative environment to be used
+for fragile beamer frames.  This option is needed to work around
+beamer bug with frame contents containing literal =\end{frame}= string
+(for example, inside example blocks).  See
+https://github.com/josephwright/beamer/issues/360
+
+The default value is =orgframe=.
+
+The option should normally not be changed, except when you need to put
+=\end{orgframe}= string inside beamer frames.
+
+A checker has been added to =M-x org-lint= to detect instances of
+~org-beamer-frame-environment~ in Org documents.
+
 *** New option ~org-export-process-citations~
 
 The new option controls whether to use citation processors to process
@@ -1003,7 +1049,51 @@ This option starts the agenda to automatically include archives,
 propagating the value for this variable to ~org-agenda-archives-mode~.
 For acceptable values and their meaning, see the value of that variable.
 
+*** New option ~org-id-link-consider-parent-id~ to allow =id:= links to parent headlines
+
+For =id:= links, when this option is enabled, ~org-store-link~ will
+look for ids from parent/ancestor headlines, if the current headline
+does not have an id.
+
+Combined with the new ability for =id:= links to use search options
+ [fn:: when =org-id-link-use-context= is =t=, which is the default],
+this allows linking to specific headlines without requiring every
+headline to have an id property, as long as the headline is unique
+within a subtree that does have an id property.
+
+For example, given this org file:
+
+#+begin_src org
+,* Parent
+:PROPERTIES:
+:ID: abc
+:END:
+,** Child 1
+,** Child 2
+#+end_src
+
+Storing a link with point at "Child 1" will produce a link
+=<id:abc::*Child 1>=, which precisely links to the "Child 1" headline
+even though it does not have its own ID.  By giving files top-level id
+properties, links to headlines in the file can also be made more
+robust by using the file id instead of the file path.
+
 ** New features
+*** =ob-tangle.el=: New flag to remove tangle targets before writing
+
+When ~org-babel-tangle-remove-file-before-write~ is set to ~t~ the
+tangle target is removed before writing.  This will allow overwriting
+read-only tangle targets.  However, when tangle target is a symlink,
+this will convert the tangle target into an ordinary file.
+
+The default value is ~auto~ -- overwrite tangle targets when they are
+read-only.
+
+*** ~org-bibtex-yank~ accepts a prefix argument
+
+When called with a prefix argument, ~org-bibtex-yank~ adds data to the
+headline of the entry at point instead of creating a new one.
+
 *** =ob-plantuml.el=: Support tikz file format output
 
 =ob-plantuml.el= now output =tikz= :file format via
@@ -1203,6 +1293,11 @@ The same can be done via startup options:
 : #+STARTUP: fnanon
 
 ** New functions and changes in function arguments
+*** New optional argument =UPDATE-HEADING= for ~org-bibtex-yank~
+
+When the new argument is non-nil, add data to the headline of the
+entry at point.
+
 *** New API functions to store data within ~org-element-cache~
 
 Elisp programs can now store data inside Org element cache.
@@ -1293,6 +1388,25 @@ as the function can also act on objects.
 
 *** ~org-export-get-parent-element~ is renamed to ~org-element-parent-element~ and moved to =lisp/org-element.el=
 
+*** ~org-insert-heading~ optional argument =TOP= is now =LEVEL=
+
+A numeric value forces a heading at that level to be inserted.  For
+backwards compatibility, non-numeric non-nil values insert level 1
+headings as before.
+
+*** New optional argument for ~org-id-get~
+
+New optional argument =INHERIT= means inherited ID properties from
+parent entries are considered when getting an entry's ID (see
+~org-id-link-consider-parent-id~ option).
+
+*** New optional argument for ~org-link-search~
+
+If a missing heading is created to match the search string, the new
+optional argument =NEW-HEADING-CONTAINER= specifies where in the
+buffer it will be added.  If not specified, new headings are created
+at level 1 at the end of the accessible part of the buffer, as before.
+
 ** Miscellaneous
 *** =org-crypt.el= now applies initial visibility settings to decrypted entries
 
@@ -1332,6 +1446,12 @@ For symmetry with =\S= and =\sect= for the section symbol, =\P= has
 been added as an another form for the pilcrow symbol currently
 available as =\para=.
 
+*** ~org-table-to-lisp~ no longer clobbers the regexp global state
+
+It does no longer use regexps.
+
+It is also faster. Large tables can be read quickly.
+
 * Version 9.6
 
 ** Important announcements and breaking changes

lisp/ob-core.el

@@ -73,10 +73,12 @@
 (declare-function org-element-parent "org-element-ast" (node))
 (declare-function org-element-type "org-element-ast" (node &optional anonymous))
 (declare-function org-element-type-p "org-element-ast" (node &optional types))
+(declare-function org-element-interpret-data "org-element" (data))
 (declare-function org-entry-get "org" (pom property &optional inherit literal-nil))
 (declare-function org-escape-code-in-region "org-src" (beg end))
 (declare-function org-forward-heading-same-level "org" (arg &optional invisible-ok))
 (declare-function org-in-commented-heading-p "org" (&optional no-inheritance))
+(declare-function org-indent-block "org" ())
 (declare-function org-indent-line "org" ())
 (declare-function org-list-get-list-end "org-list" (item struct prevs))
 (declare-function org-list-prevs-alist "org-list" (struct))
@@ -700,8 +702,9 @@ By default, consider the block at point.  However, when optional
 argument DATUM is provided, extract information from that parsed
 object instead.
 
-Return nil if point is not on a source block.  Otherwise, return
-a list with the following pattern:
+Return nil if point is not on a source block (blank lines after a
+source block are considered a part of that source block).
+Otherwise, return a list with the following pattern:
 
   (language body arguments switches name start coderef)"
   (let* ((datum (or datum (org-element-context)))
@@ -1192,11 +1195,16 @@ Return t if a code block was found at point, nil otherwise."
 	  ;; we want to restore this location after executing BODY.
 	  (outside-position
 	   (and (<= (line-beginning-position)
-		    (org-element-post-affiliated element))
+		   (org-element-post-affiliated element))
 		(point-marker)))
 	  (org-src-window-setup 'switch-invisibly))
      (when (and (org-babel-where-is-src-block-head element)
-		(org-edit-src-code))
+		(condition-case nil
+                    (org-edit-src-code)
+                  (t
+                   (org-edit-src-exit)
+                   (when outside-position (goto-char outside-position))
+                   nil)))
        (unwind-protect (progn ,@body)
 	 (org-edit-src-exit)
 	 (when outside-position (goto-char outside-position)))
@@ -1826,6 +1834,8 @@ HEADER-ARGUMENTS is alist of all the arguments."
 Return a cons cell, the `car' of which contains the TABLE less
 colnames, and the `cdr' of which contains a list of the column
 names."
+  ;; Skip over leading hlines.
+  (while (eq 'hline (car table)) (pop table))
   (if (eq 'hline (nth 1 table))
       (cons (cddr table) (car table))
     (cons (cdr table) (car table))))
@@ -1887,9 +1897,16 @@ of the vars, cnames and rnames."
           (when (and (not (equal colnames "no"))
                      ;; Compatibility note: avoid `length>', which
                      ;; isn't available until Emacs 28.
-                     (or colnames (and (> (length (cdr var)) 1)
-                                       (eq (nth 1 (cdr var)) 'hline)
-                                       (not (member 'hline (cddr (cdr var)))))))
+                     (or colnames
+                         ;; :colnames nil (default)
+                         ;; Auto-assign column names when the table
+                         ;; has hline as the second line after
+                         ;; non-hline row.
+                         (and (> (length (cdr var)) 1)
+                              (not (eq (car (cdr var)) 'hline)) ; first row
+                              (eq (nth 1 (cdr var)) 'hline) ; second row
+                              (not (member 'hline (cddr (cdr var)))) ; other rows
+                              )))
             (let ((both (org-babel-get-colnames (cdr var))))
               (setq cnames (cons (cons (car var) (cdr both))
                                  cnames))
@@ -2075,7 +2092,7 @@ With optional prefix argument ARG, jump backward ARG many source blocks."
       (goto-char (match-beginning 5)))))
 
 (defun org-babel-demarcate-block (&optional arg)
-  "Wrap or split the code in the region or on the point.
+  "Wrap or split the code in an active region or at point.
 
 With prefix argument ARG, also create a new heading at point.
 
@@ -2085,41 +2102,76 @@ is created.  In both cases if the region is demarcated and if the
 region is not active then the point is demarcated.
 
 When called within blank lines after a code block, create a new code
-block of the same language with the previous."
+block of the same language as the previous."
   (interactive "P")
   (let* ((info (org-babel-get-src-block-info 'no-eval))
 	 (start (org-babel-where-is-src-block-head))
          ;; `start' will be nil when within space lines after src block.
 	 (block (and start (match-string 0)))
-	 (headers (and start (match-string 4)))
+         (body-beg (and start (match-beginning 5)))
+         (body-end (and start (match-end 5)))
 	 (stars (concat (make-string (or (org-current-level) 1) ?*) " "))
 	 (upper-case-p (and block
 			    (let (case-fold-search)
 			      (string-match-p "#\\+BEGIN_SRC" block)))))
     (if (and info start) ;; At src block, but not within blank lines after it.
-        (mapc
-         (lambda (place)
-           (save-excursion
-             (goto-char place)
-             (let ((lang (nth 0 info))
-                   (indent (make-string (org-current-text-indentation) ?\s)))
-	       (when (string-match "^[[:space:]]*$"
-                                   (buffer-substring (line-beginning-position)
-                                                     (line-end-position)))
-                 (delete-region (line-beginning-position) (line-end-position)))
-               (insert (concat
-		        (if (looking-at "^") "" "\n")
-		        indent (if upper-case-p "#+END_SRC\n" "#+end_src\n")
-		        (if arg stars indent) "\n"
-		        indent (if upper-case-p "#+BEGIN_SRC " "#+begin_src ")
-		        lang
-		        (if (> (length headers) 1)
-			    (concat " " headers) headers)
-		        (if (looking-at "[\n\r]")
-			    ""
-			  (concat "\n" (make-string (current-column) ? )))))))
-	   (move-end-of-line 2))
-         (sort (if (org-region-active-p) (list (mark) (point)) (list (point))) #'>))
+        (let* ((copy (org-element-copy (org-element-at-point)))
+               (before (org-element-begin copy))
+               (beyond (org-element-end copy))
+               (parts
+                (if (org-region-active-p)
+                    (list body-beg (region-beginning) (region-end) body-end)
+                  (list body-beg (point) body-end)))
+               (pads ;; To calculate left-side white-space padding.
+                (if (org-region-active-p)
+                    (list (region-beginning) (region-end))
+                  (list (point))))
+               (n (- (length parts) 2)) ;; 1 or 2 parts in `dolist' below.
+               ;; `post-blank' caches the property before setting it to 0.
+               (post-blank (org-element-property :post-blank copy)))
+          ;; Point or region are within body when parts is in increasing order.
+          (unless (apply #'<= parts)
+            (user-error "Select within the source block body to split it"))
+          (setq parts (mapcar (lambda (p) (buffer-substring (car p) (cdr p)))
+                              (seq-mapn #'cons parts (cdr parts))))
+          ;; Map positions to columns for white-space padding.
+          (setq pads (mapcar (lambda (p) (save-excursion
+                                           (goto-char p)
+                                           (current-column)))
+                             pads))
+          (push 0 pads) ;; The 1st part never requires white-space padding.
+          (setq parts (mapcar (lambda (p) (string-join
+                                           (list (make-string (car p) ?\s)
+                                                 (cdr p))))
+                              (seq-mapn #'cons pads parts)))
+          (delete-region before beyond)
+          ;; Set `:post-blank' to 0.  We take care of spacing between blocks.
+          (org-element-put-property copy :post-blank 0)
+          (org-element-put-property copy :value (car parts))
+          (insert (org-element-interpret-data copy))
+          ;; `org-indent-block' may see another `org-element' (e.g. paragraph)
+          ;; immediately after the block.  Ensure to indent the inserted block
+          ;; and move point to its end.
+          (org-babel-previous-src-block 1)
+          (org-indent-block)
+          (goto-char (org-element-end (org-element-at-point)))
+          (org-element-put-property copy :caption nil)
+          (org-element-put-property copy :name nil)
+          ;; Insert the 2nd block, and the 3rd block when region is active.
+          (dolist (part (cdr parts))
+            (org-element-put-property copy :value part)
+            (insert (if arg (concat stars "\n") "\n"))
+            (cl-decf n)
+            (when (= n 0)
+              ;; Use `post-blank' to reset the property of the last block.
+              (org-element-put-property copy :post-blank post-blank))
+            (insert (org-element-interpret-data copy))
+            ;; Ensure to indent the inserted block and move point to its end.
+            (org-babel-previous-src-block 1)
+            (org-indent-block)
+            (goto-char (org-element-end (org-element-at-point))))
+          ;; Leave point at the last inserted block.
+          (goto-char (org-babel-previous-src-block 1)))
       (let ((start (point))
 	    (lang (or (car info) ; Reuse language from previous block.
                       (completing-read

lisp/ob-gnuplot.el

@@ -187,7 +187,7 @@ code."
       ;; value of the variable
       (mapc (lambda (pair)
 	      (setq body (replace-regexp-in-string
-			  (format "\\$%s" (car pair)) (cdr pair) body)))
+			  (format "\\$%s" (car pair)) (cdr pair) body t t)))
 	    vars)
       (when prologue (funcall add-to-body prologue))
       (when epilogue (setq body (concat body "\n" epilogue)))

lisp/ob-latex.el

@@ -136,7 +136,7 @@ exporting the literal LaTeX source."
                  (regexp-quote (format "%S" (car pair)))
                  (if (stringp (cdr pair))
                      (cdr pair) (format "%S" (cdr pair)))
-                 body)))
+                 body t t)))
 	(org-babel--get-vars params))
   (let ((prologue (cdr (assq :prologue params)))
         (epilogue (cdr (assq :epilogue params))))

lisp/ob-lilypond.el

@@ -142,7 +142,7 @@ blocks.")
 	       (replace-regexp-in-string
 		(concat "$" (regexp-quote name))
 		(if (stringp value) value (format "%S" value))
-		body))))
+		body t t))))
      vars)
     (concat
      (and prologue (concat prologue "\n"))

lisp/ob-org.el

@@ -51,7 +51,7 @@ $VAR instances are replaced by VAR values defined in PARAMS."
     (setq body (replace-regexp-in-string
 		(regexp-quote (format "$%s" (car var)))
 		(format "%s" (cdr var))
-		body nil 'literal)))
+		body 'fixedcase 'literal)))
   
   (let ((prologue (cdr (assq :prologue params)))
         (epilogue (cdr (assq :epilogue params))))

lisp/ob-sql.el

@@ -113,9 +113,7 @@
 Set `sql-product' in Org edit buffer according to the
 corresponding :engine source block header argument."
   (let ((product (cdr (assq :engine (nth 2 info)))))
-    (condition-case nil
-        (sql-set-product product)
-      (user-error "Cannot set `sql-product' in Org Src edit buffer"))))
+    (sql-set-product product)))
 
 (defun org-babel-sql-dbstring-mysql (host port user password database)
   "Make MySQL cmd line args for database connection.  Pass nil to omit that arg."
@@ -409,11 +407,11 @@ argument mechanism."
                                val (if sqlite
                                        nil
                                      '(:fmt (lambda (el) (if (stringp el)
-                                                             el
-                                                           (format "%S" el))))))))
+                                                        el
+                                                      (format "%S" el))))))))
                     data-file)
                 (if (stringp val) val (format "%S" val))))
-	    body)))
+	    body t t)))
    vars)
   body)
 

lisp/ob-tangle.el

@@ -166,6 +166,23 @@ read-write permissions for the user, read-only for everyone else."
   :package-version '(Org . "9.6")
   :type 'integer)
 
+(defcustom org-babel-tangle-remove-file-before-write 'auto
+  "How to overwrite the existing tangle target.
+When set to nil, `org-babel-tangle' will replace contents of an existing
+tangle target (and fail when tangle target is read-only).
+When set to t, the tangle target (including read-only) will be deleted
+first and a new file, possibly with different ownership and
+permissions, will be created.
+When set to symbol `auto', overwrite read-only tangle targets and
+replace contents otherwise."
+  :group 'org-babel-tangle
+  :package-version '(Org . "9.7")
+  :type '(choice
+	  (const :tag "Replace contents, but keep the same file" nil)
+          (const :tag "Re-create file" t)
+          (const :tag "Re-create when read-only" auto))
+  :safe t)
+
 (defun org-babel-find-file-noselect-refresh (file)
   "Find file ensuring that the latest changes on disk are
 represented in the file."
@@ -323,7 +340,19 @@ matching a regular expression."
                        (error "Not allowed to tangle into the same file as self"))
                      ;; We do not erase, but overwrite previous file
                      ;; to preserve any existing symlinks.
-		     (write-region nil nil file-name)
+                     ;; This behavior is modified using
+                     ;; `org-babel-tangle-remove-file-before-write' to
+                     ;; tangle to read-only files.
+                     (when (and
+			    (file-exists-p file-name)
+                            (pcase org-babel-tangle-remove-file-before-write
+                              (`auto (not (file-writable-p file-name)))
+                              (`t t)
+                              (`nil nil)
+                              (_ (error "Invalid value of `org-babel-tangle-remove-file-before-write': %S"
+					org-babel-tangle-remove-file-before-write))))
+                       (delete-file file-name))
+                     (write-region nil nil file-name)
 		     (mapc (lambda (mode) (set-file-modes file-name mode)) modes))
                    (push file-name path-collector))))))
 	 (if (equal arg '(4))

lisp/oc-basic.el

@@ -79,6 +79,12 @@
 (declare-function org-open-file "org" (path &optional in-emacs line search))
 
 (declare-function org-element-interpret-data "org-element" (data))
+(declare-function org-element-parse-secondary-string "org-element" (string restriction &optional parent))
+(declare-function org-element-map "org-element"
+                  ( data types fun
+                    &optional
+                    info first-match no-recursion
+                    with-affiliated no-undefer))
 (declare-function org-element-property "org-element-ast" (property node))
 (declare-function org-element-type-p "org-element-ast" (node types))
 (declare-function org-element-contents "org-element-ast" (node))
@@ -367,7 +373,7 @@ personal names of the form \"family, given\"."
     (cond
      ((stringp names) (setq names-string names))
      ((org-element-type-p names 'raw)
-      (setq names-string (mapconcat #'identity (org-element-contents names))
+      (setq names-string (mapconcat #'identity (org-element-contents names) "")
             raw-p t)))
     (when names-string
       (setq names-string
@@ -463,6 +469,38 @@ necessary, unless optional argument NO-SUFFIX is non-nil."
                     new))))
          (if no-suffix year (concat year suffix)))))))
 
+(defun org-cite-basic--print-bibtex-string (element &optional info)
+  "Print Bibtex formatted string ELEMENT, according to Bibtex syntax.
+Remove all the {...} that are not a part of LaTeX macros and parse the
+LaTeX fragments.  Do nothing when current backend is derived from
+LaTeX, according to INFO.
+
+Return updated ELEMENT."
+  (if (org-export-derived-backend-p (plist-get info :back-end) 'latex)
+      ;; Derived from LaTeX, no need to use manual ad-hoc LaTeX
+      ;; parser.
+      element
+    ;; Convert ELEMENT to anonymous when ELEMENT is string.
+    ;; Otherwise, we cannot modify ELEMENT by side effect.
+    (when (org-element-type-p element 'plain-text)
+      (setq element (org-element-create 'anonymous nil element)))
+    ;; Approximately parse LaTeX fragments, assuming Org mode syntax
+    ;; (it is close to original LaTeX, and we do not want to
+    ;; re-implement complete LaTeX parser here))
+    (org-element-map element t
+      (lambda (str)
+        (when (stringp str)
+          (org-element-set
+           str
+           (org-element-parse-secondary-string
+            str '(latex-fragment entity))))))
+    ;; Strip the remaining { and }.
+    (org-element-map element t
+      (lambda (str)
+        (when (stringp str)
+          (org-element-set str (replace-regexp-in-string "[{}]" "" str)))))
+    element))
+
 (defun org-cite-basic--print-entry (entry style &optional info)
   "Format ENTRY according to STYLE string.
 ENTRY is an alist, as returned by `org-cite-basic--get-entry'.
@@ -474,27 +512,29 @@ Optional argument INFO is the export state, as a property list."
              (org-cite-basic--get-field 'journal entry info)
              (org-cite-basic--get-field 'institution entry info)
              (org-cite-basic--get-field 'school entry info))))
-    (pcase style
-      ("plain"
-       (let ((year (org-cite-basic--get-year entry info 'no-suffix)))
-         (org-cite-concat
-          (org-cite-basic--shorten-names author) ". "
-          title (and from (list ", " from)) ", " year ".")))
-      ("numeric"
-       (let ((n (org-cite-basic--key-number (cdr (assq 'id entry)) info))
-             (year (org-cite-basic--get-year entry info 'no-suffix)))
-         (org-cite-concat
-          (format "[%d] " n) author ", "
-          (org-cite-emphasize 'italic title)
-          (and from (list ", " from)) ", "
-          year ".")))
-      ;; Default to author-year.  Use year disambiguation there.
-      (_
-       (let ((year (org-cite-basic--get-year entry info)))
-         (org-cite-concat
-          author " (" year "). "
-          (org-cite-emphasize 'italic title)
-          (and from (list ", " from)) "."))))))
+    (org-cite-basic--print-bibtex-string
+     (pcase style
+       ("plain"
+        (let ((year (org-cite-basic--get-year entry info 'no-suffix)))
+          (org-cite-concat
+           (org-cite-basic--shorten-names author) ". "
+           title (and from (list ", " from)) ", " year ".")))
+       ("numeric"
+        (let ((n (org-cite-basic--key-number (cdr (assq 'id entry)) info))
+              (year (org-cite-basic--get-year entry info 'no-suffix)))
+          (org-cite-concat
+           (format "[%d] " n) author ", "
+           (org-cite-emphasize 'italic title)
+           (and from (list ", " from)) ", "
+           year ".")))
+       ;; Default to author-year.  Use year disambiguation there.
+       (_
+        (let ((year (org-cite-basic--get-year entry info)))
+          (org-cite-concat
+           author " (" year "). "
+           (org-cite-emphasize 'italic title)
+           (and from (list ", " from)) "."))))
+     info)))
 
 
 ;;; "Activate" capability

lisp/ol-bbdb.el

@@ -226,7 +226,7 @@ date year)."
 
 ;;; Implementation
 
-(defun org-bbdb-store-link ()
+(defun org-bbdb-store-link (&optional _interactive?)
   "Store a link to a BBDB database entry."
   (when (eq major-mode 'bbdb-mode)
     ;; This is BBDB, we make this link!

lisp/ol-bibtex.el

@@ -507,7 +507,7 @@ ARG, when non-nil, is a universal prefix argument.  See
 `org-open-file' for details."
   (org-link-open-as-file path arg))
 
-(defun org-bibtex-store-link ()
+(defun org-bibtex-store-link (&optional _interactive?)
   "Store a link to a BibTeX entry."
   (when (eq major-mode 'bibtex-mode)
     (let* ((search (org-create-file-search-in-bibtex))
@@ -640,22 +640,23 @@ With prefix argument OPTIONAL also prompt for optional fields."
   "Return headline text according to ENTRY title."
   (cdr (assq :title entry)))
 
-(defun org-bibtex-create (&optional arg nonew)
+(defun org-bibtex-create (&optional arg update-heading)
   "Create a new entry at the given level.
-With a prefix arg, query for optional fields as well.
-If nonew is t, add data to the headline of the entry at point."
+With a prefix ARG, query for optional fields as well.
+If UPDATE-HEADING is non-nil, add data to the headline of the entry at
+point."
   (interactive "P")
   (let* ((type (completing-read
 		"Type: " (mapcar (lambda (type)
 				   (substring (symbol-name (car type)) 1))
 				 org-bibtex-types)
-		nil nil (when nonew
-			  (org-bibtex-get org-bibtex-type-property-name))))
+		nil nil (when update-heading
+		      (org-bibtex-get org-bibtex-type-property-name))))
 	 (type (if (keywordp type) type (intern (concat ":" type))))
-	 (org-bibtex-treat-headline-as-title (if nonew nil t)))
+	 (org-bibtex-treat-headline-as-title (if update-heading nil t)))
     (unless (assoc type org-bibtex-types)
       (error "Type:%s is not known" type))
-    (if nonew
+    (if update-heading
 	(org-back-to-heading)
       (org-insert-heading)
       (let ((title (org-bibtex-ask :title)))
@@ -722,29 +723,32 @@ Return the number of saved entries."
   (interactive "fFile: ")
   (org-bibtex-read-buffer (find-file-noselect file 'nowarn 'rawfile)))
 
-(defun org-bibtex-write (&optional noindent)
+(defun org-bibtex-write (&optional noindent update-heading)
   "Insert a heading built from the first element of `org-bibtex-entries'.
 When optional argument NOINDENT is non-nil, do not indent the properties
-drawer."
+drawer.  If UPDATE-HEADING is non-nil, add data to the headline of the
+entry at point."
   (interactive)
   (unless org-bibtex-entries
     (error "No entries in `org-bibtex-entries'"))
   (let* ((entry (pop org-bibtex-entries))
 	 (org-special-properties nil) ; avoids errors with `org-entry-put'
 	 (val (lambda (field) (cdr (assoc field entry))))
-	 (togtag (lambda (tag) (org-toggle-tag tag 'on))))
-    (org-insert-heading)
-    (insert (funcall org-bibtex-headline-format-function entry))
-    (insert "\n:PROPERTIES:\n")
-    (org-bibtex-put "TITLE" (funcall val :title) 'insert)
+	 (togtag (lambda (tag) (org-toggle-tag tag 'on)))
+         (insert-raw (not update-heading)))
+    (unless update-heading
+      (org-insert-heading)
+      (insert (funcall org-bibtex-headline-format-function entry))
+      (insert "\n:PROPERTIES:\n"))
+    (org-bibtex-put "TITLE" (funcall val :title) insert-raw)
     (org-bibtex-put org-bibtex-type-property-name
 		    (downcase (funcall val :type))
-                    'insert)
+                    insert-raw)
     (dolist (pair entry)
       (pcase (car pair)
 	(:title    nil)
 	(:type     nil)
-	(:key      (org-bibtex-put org-bibtex-key-property (cdr pair) 'insert))
+	(:key      (org-bibtex-put org-bibtex-key-property (cdr pair) insert-raw))
 	(:keywords (if org-bibtex-tags-are-keywords
 		       (dolist (kw (split-string (cdr pair) ", *"))
 			 (funcall
@@ -752,25 +756,28 @@ drawer."
 			  (replace-regexp-in-string
 			   "[^[:alnum:]_@#%]" ""
 			   (replace-regexp-in-string "[ \t]+" "_" kw))))
-		     (org-bibtex-put (car pair) (cdr pair) 'insert)))
-	(_ (org-bibtex-put (car pair) (cdr pair) 'insert))))
-    (insert ":END:\n")
+		     (org-bibtex-put (car pair) (cdr pair) insert-raw)))
+	(_ (org-bibtex-put (car pair) (cdr pair) insert-raw))))
+    (unless update-heading
+      (insert ":END:\n"))
     (mapc togtag org-bibtex-tags)
     (unless noindent
       (org-indent-region
        (save-excursion (org-back-to-heading t) (point))
        (point)))))
 
-(defun org-bibtex-yank ()
-  "If kill ring holds a bibtex entry yank it as an Org headline."
-  (interactive)
+(defun org-bibtex-yank (&optional update-heading)
+  "If kill ring holds a bibtex entry yank it as an Org headline.
+When called with non-nil prefix argument UPDATE-HEADING, add data to the
+headline of the entry at point."
+  (interactive "P")
   (let (entry)
     (with-temp-buffer
       (yank 1)
       (bibtex-mode)
       (setf entry (org-bibtex-read)))
     (if entry
-	(org-bibtex-write)
+	(org-bibtex-write nil update-heading)
       (error "Yanked text does not appear to contain a BibTeX entry"))))
 
 (defun org-bibtex-import-from-file (file)

lisp/ol-docview.el

@@ -83,7 +83,7 @@
       (error "No such file: %s" path))
     (when page (doc-view-goto-page page))))
 
-(defun org-docview-store-link ()
+(defun org-docview-store-link (&optional _interactive?)
   "Store a link to a docview buffer."
   (when (eq major-mode 'doc-view-mode)
     ;; This buffer is in doc-view-mode

lisp/ol-eshell.el

@@ -60,7 +60,7 @@ followed by a colon."
     (insert command)
     (eshell-send-input)))
 
-(defun org-eshell-store-link ()
+(defun org-eshell-store-link (&optional _interactive?)
   "Store eshell link.
 When opened, the link switches back to the current eshell buffer and
 the current working directory."

lisp/ol-eww.el

@@ -62,7 +62,7 @@
   "Open URL with Eww in the current buffer."
   (eww url))
 
-(defun org-eww-store-link ()
+(defun org-eww-store-link (&optional _interactive?)
   "Store a link to the url of an EWW buffer."
   (when (eq major-mode 'eww-mode)
     (org-link-store-props

lisp/ol-gnus.el

@@ -123,7 +123,7 @@ If `org-store-link' was called with a prefix arg the meaning of
 	      (url-encode-url message-id))
     (concat "gnus:" group "#" message-id)))
 
-(defun org-gnus-store-link ()
+(defun org-gnus-store-link (&optional _interactive?)
   "Store a link to a Gnus folder or message."
   (pcase major-mode
     (`gnus-group-mode

lisp/ol-info.el

@@ -50,7 +50,7 @@
                          :insert-description #'org-info-description-as-command)
 
 ;; Implementation
-(defun org-info-store-link ()
+(defun org-info-store-link (&optional _interactive?)
   "Store a link to an Info file and node."
   (when (eq major-mode 'Info-mode)
     (let ((link (concat "info:"

lisp/ol-irc.el

@@ -103,7 +103,7 @@ attributes that are found."
     parts))
 
 ;;;###autoload
-(defun org-irc-store-link ()
+(defun org-irc-store-link (&optional _interactive?)
   "Dispatch to the appropriate function to store a link to an IRC session."
   (cond
    ((eq major-mode 'erc-mode)

lisp/ol-man.el

@@ -82,7 +82,7 @@ matched strings in man buffer."
             (set-window-point window point)
             (set-window-start window point)))))))
 
-(defun org-man-store-link ()
+(defun org-man-store-link (&optional _interactive?)
   "Store a link to a README file."
   (when (memq major-mode '(Man-mode woman-mode))
     ;; This is a man page, we do make this link

lisp/ol-mhe.el

@@ -80,7 +80,7 @@ supported by MH-E."
 (org-link-set-parameters "mhe" :follow #'org-mhe-open :store #'org-mhe-store-link)
 
 ;; Implementation
-(defun org-mhe-store-link ()
+(defun org-mhe-store-link (&optional _interactive?)
   "Store a link to an MH-E folder or message."
   (when (or (eq major-mode 'mh-folder-mode)
 	    (eq major-mode 'mh-show-mode))

lisp/ol-rmail.el

@@ -51,7 +51,7 @@
 			 :store #'org-rmail-store-link)
 
 ;; Implementation
-(defun org-rmail-store-link ()
+(defun org-rmail-store-link (&optional _interactive?)
   "Store a link to an Rmail folder or message."
   (when (or (eq major-mode 'rmail-mode)
 	    (eq major-mode 'rmail-summary-mode))

lisp/ol.el

@@ -52,18 +52,19 @@
 (declare-function org-do-occur "org" (regexp &optional cleanup))
 (declare-function org-element-at-point "org-element" (&optional pom cached-only))
 (declare-function org-element-cache-refresh "org-element" (pos))
+(declare-function org-element-cache-reset "org-element" (&optional all no-persistence))
 (declare-function org-element-context "org-element" (&optional element))
 (declare-function org-element-lineage "org-element-ast" (datum &optional types with-self))
 (declare-function org-element-link-parser "org-element" ())
 (declare-function org-element-property "org-element-ast" (property node))
 (declare-function org-element-begin "org-element" (node))
+(declare-function org-element-end "org-element" (node))
 (declare-function org-element-type-p "org-element-ast" (node types))
 (declare-function org-element-update-syntax "org-element" ())
 (declare-function org-entry-get "org" (pom property &optional inherit literal-nil))
 (declare-function org-find-property "org" (property &optional value))
 (declare-function org-get-heading "org" (&optional no-tags no-todo no-priority no-comment))
 (declare-function org-id-find-id-file "org-id" (id))
-(declare-function org-id-store-link "org-id" ())
 (declare-function org-insert-heading "org" (&optional arg invisible-ok top))
 (declare-function org-load-modules-maybe "org" (&optional force))
 (declare-function org-mark-ring-push "org" (&optional pos buffer))
@@ -532,6 +533,16 @@ links more efficient."
 
 (defvar-local org-target-link-regexp nil
   "Regular expression matching radio targets in plain text.")
+(defconst org-target-link-regexp-limit (ash 2 12)
+  "Maximum allowed length of regexp.
+The number should generally be ~order of magnitude smaller than
+MAX_BUF_SIZE in src/regex-emacs.c.  The number of regexp-emacs.c is
+for processed regexp, which appears to be larger compared to the
+original string length.")
+(defvar-local org-target-link-regexps nil
+  "List of regular expressions matching radio targets in plain text.
+This list is non-nil, when a single regexp would be too long to match
+all the possible targets, exceeding Emacs' regexp length limit.")
 
 (defvar org-link-types-re nil
   "Matches a link that has a url-like prefix like \"http:\".")
@@ -818,6 +829,74 @@ spec."
   (org-with-point-at (car region)
     (not (org-in-regexp org-link-any-re))))
 
+(defun org-link--try-link-store-functions (interactive?)
+  "Try storing external links, prompting if more than one is possible.
+
+Each function returned by `org-store-link-functions' is called in
+turn.  If multiple functions return non-nil, prompt for which
+link should be stored.
+
+Argument INTERACTIVE? indicates whether `org-store-link' was
+called interactively and is passed to the link store functions.
+
+Return t when a link has been stored in `org-link-store-props'."
+  (let ((results-alist nil))
+    (dolist (f (org-store-link-functions))
+      (when (condition-case nil
+                (funcall f interactive?)
+              ;; FIXME: The store function used (< Org 9.7) to accept
+              ;; no arguments; provide backward compatibility support
+              ;; for them.
+              (wrong-number-of-arguments
+               (funcall f)))
+        ;; FIXME: return value is not link's plist, so we store the
+        ;; new value before it is modified.  It would be cleaner to
+        ;; ask store link functions to return the plist instead.
+        (push (cons f (copy-sequence org-store-link-plist))
+              results-alist)))
+    (pcase results-alist
+      (`nil nil)
+      (`((,_ . ,_)) t)	;single choice: nothing to do
+      (`((,name . ,_) . ,_)
+       ;; Reinstate link plist associated to the chosen
+       ;; function.
+       (apply #'org-link-store-props
+              (cdr (assoc-string
+                    (completing-read
+                     (format "Store link with (default %s): " name)
+                     (mapcar #'car results-alist)
+                     nil t nil nil (symbol-name name))
+                    results-alist)))
+       t))))
+
+(defun org-link--add-to-stored-links (link desc)
+  "Add LINK to `org-stored-links' with description DESC."
+  (cond
+   ((not (member (list link desc) org-stored-links))
+    (push (list link desc) org-stored-links)
+    (message "Stored: %s" (or desc link)))
+   ((equal (list link desc) (car org-stored-links))
+    (message "This link has already been stored"))
+   (t
+    (setq org-stored-links
+          (delete (list link desc) org-stored-links))
+    (push (list link desc) org-stored-links)
+    (message "Link moved to front: %s" (or desc link)))))
+
+(defun org-link--file-link-to-here ()
+  "Return as (LINK . DESC) a file link with search string to here."
+  (let ((link (concat "file:"
+                      (abbreviate-file-name
+                       (buffer-file-name (buffer-base-buffer)))))
+        desc)
+    (when org-link-context-for-files
+      (pcase (org-link-precise-link-target)
+        (`nil nil)
+        (`(,search-string ,search-desc ,_position)
+         (setq link (format "%s::%s" link search-string))
+         (setq desc search-desc))))
+    (cons link desc)))
+
 
 ;;; Public API
 
@@ -1044,7 +1123,9 @@ LINK is escaped with backslashes for inclusion in buffer."
   "List of functions that are called to create and store a link.
 
 The functions are defined in the `:store' property of
-`org-link-parameters'.
+`org-link-parameters'.  Each function should accept an argument
+INTERACTIVE? which indicates whether the user has initiated
+`org-store-link' interactively.
 
 Each function will be called in turn until one returns a non-nil
 value.  Each function should check if it is responsible for
@@ -1179,7 +1260,7 @@ Optional argument ARG is passed to `org-open-file' when S is a
     (`nil (user-error "No valid link in %S" s))
     (link (org-link-open link arg))))
 
-(defun org-link-search (s &optional avoid-pos stealth)
+(defun org-link-search (s &optional avoid-pos stealth new-heading-container)
   "Search for a search string S in the accessible part of the buffer.
 
 If S starts with \"#\", it triggers a custom ID search.
@@ -1199,6 +1280,13 @@ When optional argument STEALTH is non-nil, do not modify
 visibility around point, thus ignoring `org-show-context-detail'
 variable.
 
+When optional argument NEW-HEADING-CONTAINER is an element, any
+new heading that is created (see
+`org-link-search-must-match-exact-headline') will be added as a
+subheading of NEW-HEADING-CONTAINER.  Otherwise, new headings are
+created at level 1 at the end of the accessible part of the
+buffer.
+
 Search is case-insensitive and ignores white spaces.  Return type
 of matched result, which is either `dedicated' or `fuzzy'.  Search
 respects buffer narrowing."
@@ -1297,11 +1385,24 @@ respects buffer narrowing."
      ((and (derived-mode-p 'org-mode)
 	   (eq org-link-search-must-match-exact-headline 'query-to-create)
 	   (yes-or-no-p "No match - create this as a new heading? "))
-      (goto-char (point-max))
-      (unless (bolp) (newline))
-      (org-insert-heading nil t t)
-      (insert s "\n")
-      (forward-line -1))
+      (let* ((container-ok (and new-heading-container
+                                (org-element-type-p new-heading-container '(headline))))
+             (new-heading-position (if container-ok
+                                       (- (org-element-end new-heading-container) 1)
+                                     (point-max)))
+             (new-heading-level (if container-ok
+                                    (+ 1 (org-element-property :level new-heading-container))
+                                  1)))
+        ;; Need to widen when target is outside accessible portion of
+        ;; buffer, since the we want the user to end up there.
+        (unless (and (<= (point-min) new-heading-position)
+                     (>= (point-max) new-heading-position))
+          (widen))
+        (goto-char new-heading-position)
+        (unless (bolp) (newline))
+        (org-insert-heading nil t new-heading-level)
+        (insert (if starred (substring s 1) s) "\n")
+        (forward-line -1)))
      ;; Only headlines are looked after.  No need to process
      ;; further: throw an error.
      ((and (derived-mode-p 'org-mode)
@@ -1351,6 +1452,70 @@ priority cookie or tag."
 	  (org-link--normalize-string
 	   (or string (org-get-heading t t t t)))))
 
+(defun org-link-precise-link-target ()
+  "Determine search string and description for storing a link.
+
+If a search string (see `org-link-search') is found, return
+list (SEARCH-STRING DESC POSITION).  Otherwise, return nil.
+
+If there is an active region, the contents (or a part of it, see
+`org-link-context-for-files') is used as the search string.
+
+In Org buffers, if point is at a named element (such as a source
+block), the name is used for the search string.  If at a heading,
+its CUSTOM_ID is used to form a search string of the form
+\"#id\", if present, otherwise the current heading text is used
+in the form \"*Heading\".
+
+If none of those finds a suitable search string, the current line
+is used as the search string.
+
+The description DESC is nil (meaning the user will be prompted
+for a description when inserting the link) for search strings
+based on a region or the current line.  For other cases, DESC is
+a cleaned-up version of the name or heading at point.
+
+POSITION is the buffer position at which the search string
+matches."
+  (let* ((region (org-link--context-from-region))
+         (result
+          (cond
+           (region
+            (list (org-link--normalize-string region t)
+                  nil
+                  (region-beginning)))
+
+           ((derived-mode-p 'org-mode)
+            (let* ((element (org-element-at-point))
+                   (name (org-element-property :name element))
+                   (heading (org-element-lineage element '(headline inlinetask) t))
+                   (custom-id (org-entry-get heading "CUSTOM_ID")))
+              (cond
+               (name
+                (list name
+                      name
+                      (org-element-begin element)))
+               ((org-before-first-heading-p)
+                (list (org-link--normalize-string (org-current-line-string) t)
+                      nil
+                      (line-beginning-position)))
+               (heading
+                (list (if custom-id (concat "#" custom-id)
+                        (org-link-heading-search-string))
+                      (org-link--normalize-string
+                       (org-get-heading t t t t))
+                      (org-element-begin heading))))))
+
+           ;; Not in an org-mode buffer, no region
+           (t
+            (list (org-link--normalize-string (org-current-line-string) t)
+                  nil
+                  (line-beginning-position))))))
+
+    ;; Only use search option if there is some text.
+    (when (org-string-nw-p (car result))
+      result)))
+
 (defun org-link-open-as-file (path in-emacs)
   "Pretend PATH is a file name and open it.
 
@@ -1423,7 +1588,7 @@ PATH is a symbol name, as a string."
     ((and (pred boundp) variable) (describe-variable variable))
     (name (user-error "Unknown function or variable: %s" name))))
 
-(defun org-link--store-help ()
+(defun org-link--store-help (&optional _interactive?)
   "Store \"help\" type link."
   (when (eq major-mode 'help-mode)
     (let ((symbol
@@ -1558,7 +1723,12 @@ prefix ARG forces storing a link for each line in the
 active region.
 
 Assume the function is called interactively if INTERACTIVE? is
-non-nil."
+non-nil.
+
+In Org buffers, an additional \"human-readable\" simple file link
+is stored as an alternative to persistent org-id or other links,
+if at a heading with a CUSTOM_ID property or an element with a
+NAME."
   (interactive "P\np")
   (org-load-modules-maybe)
   (if (and (equal arg '(64)) (org-region-active-p))
@@ -1573,36 +1743,19 @@ non-nil."
 	    (move-beginning-of-line 2)
 	    (set-mark (point)))))
     (setq org-store-link-plist nil)
-    (let (link cpltxt desc search custom-id agenda-link) ;; description
+    ;; Negate `org-context-in-file-links' when given a single universal arg.
+    (let ((org-link-context-for-files (org-xor org-link-context-for-files
+                                               (equal arg '(4))))
+          link cpltxt desc search agenda-link) ;; description
       (cond
        ;; Store a link using an external link type, if any function is
-       ;; available. If more than one can generate a link from current
-       ;; location, ask which one to use.
+       ;; available, unless external link types are skipped for this
+       ;; call using two universal args.  If more than one function
+       ;; can generate a link from current location, ask the user
+       ;; which one to use.
        ((and (not (equal arg '(16)))
-	     (let ((results-alist nil))
-	       (dolist (f (org-store-link-functions))
-		 (when (funcall f)
-		   ;; XXX: return value is not link's plist, so we
-		   ;; store the new value before it is modified.  It
-		   ;; would be cleaner to ask store link functions to
-		   ;; return the plist instead.
-		   (push (cons f (copy-sequence org-store-link-plist))
-			 results-alist)))
-	       (pcase results-alist
-		 (`nil nil)
-		 (`((,_ . ,_)) t)	;single choice: nothing to do
-		 (`((,name . ,_) . ,_)
-		  ;; Reinstate link plist associated to the chosen
-		  ;; function.
-		  (apply #'org-link-store-props
-			 (cdr (assoc-string
-			       (completing-read
-                                (format "Store link with (default %s): " name)
-                                (mapcar #'car results-alist)
-                                nil t nil nil (symbol-name name))
-			       results-alist)))
-		  t))))
-	(setq link (plist-get org-store-link-plist :link))
+             (org-link--try-link-store-functions interactive?))
+        (setq link (plist-get org-store-link-plist :link))
         ;; If store function actually set `:description' property, use
         ;; it, even if it is nil.  Otherwise, fallback to nil (ask user).
 	(setq desc (plist-get org-store-link-plist :description)))
@@ -1653,6 +1806,7 @@ non-nil."
 	    (org-with-point-at m
 	      (setq agenda-link (org-store-link nil interactive?))))))
 
+       ;; Calendar mode
        ((eq major-mode 'calendar-mode)
 	(let ((cd (calendar-cursor-to-date)))
 	  (setq link
@@ -1661,6 +1815,7 @@ non-nil."
 		 (org-encode-time 0 0 0 (nth 1 cd) (nth 0 cd) (nth 2 cd))))
 	  (org-link-store-props :type "calendar" :date cd)))
 
+       ;; Image mode
        ((eq major-mode 'image-mode)
 	(setq cpltxt (concat "file:"
 			     (abbreviate-file-name buffer-file-name))
@@ -1678,15 +1833,22 @@ non-nil."
 	  (setq cpltxt (concat "file:" file)
 		link cpltxt)))
 
+       ;; Try `org-create-file-search-functions`.  If any are
+       ;; successful, create a file link to the current buffer with
+       ;; the provided search string.  (sets `link` and `cpltxt` to
+       ;; the same thing; it looks like the intention originally was
+       ;; that cpltxt was a description, which might have been set by
+       ;; the search-function (removed in switch to lexical binding)).
        ((setq search (run-hook-with-args-until-success
 		      'org-create-file-search-functions))
 	(setq link (concat "file:" (abbreviate-file-name buffer-file-name)
 			   "::" search))
 	(setq cpltxt (or link))) ;; description
 
+       ;; Main logic for storing built-in link types in org-mode
+       ;; buffers
        ((and (buffer-file-name (buffer-base-buffer)) (derived-mode-p 'org-mode))
 	(org-with-limited-levels
-	 (setq custom-id (org-entry-get nil "CUSTOM_ID"))
 	 (cond
 	  ;; Store a link using the target at point
 	  ((org-in-regexp "[^<]<<\\([^<>]+\\)>>[^>]" 1)
@@ -1700,74 +1862,21 @@ non-nil."
                  ;; links.  Maybe the case of identical target and
                  ;; description should be handled by `org-insert-link'.
                  cpltxt nil
-                 desc nil
-                 ;; Do not append #CUSTOM_ID link below.
-                 custom-id nil))
-	  ((and (featurep 'org-id)
-		(or (eq org-id-link-to-org-use-id t)
-		    (and interactive?
-			 (or (eq org-id-link-to-org-use-id 'create-if-interactive)
-			     (and (eq org-id-link-to-org-use-id
-				      'create-if-interactive-and-no-custom-id)
-				  (not custom-id))))
-		    (and org-id-link-to-org-use-id (org-entry-get nil "ID"))))
-	   ;; Store a link using the ID at point
-	   (setq link (condition-case nil
-			  (prog1 (org-id-store-link)
-			    (setq desc (plist-get org-store-link-plist :description)))
-			(error
-			 ;; Probably before first headline, link only to file
-			 (concat "file:"
-				 (abbreviate-file-name
-				  (buffer-file-name (buffer-base-buffer))))))))
-	  (t
+                 desc nil))
+          (t
 	   ;; Just link to current headline.
-	   (setq cpltxt (concat "file:"
-				(abbreviate-file-name
-				 (buffer-file-name (buffer-base-buffer)))))
-	   ;; Add a context search string.
-	   (when (org-xor org-link-context-for-files (equal arg '(4)))
-	     (let* ((element (org-element-at-point))
-		    (name (org-element-property :name element))
-		    (context
-		     (cond
-		      ((let ((region (org-link--context-from-region)))
-			 (and region (org-link--normalize-string region t))))
-		      (name)
-		      ((org-before-first-heading-p)
-		       (org-link--normalize-string (org-current-line-string) t))
-		      (t (org-link-heading-search-string)))))
-	       (when (org-string-nw-p context)
-		 (setq cpltxt (format "%s::%s" cpltxt context))
-		 (setq desc
-		       (or name
-			   ;; Although description is not a search
-			   ;; string, use `org-link--normalize-string'
-			   ;; to prettify it (contiguous white spaces)
-			   ;; and remove volatile contents (statistics
-			   ;; cookies).
-			   (and (not (org-before-first-heading-p))
-				(org-link--normalize-string
-				 (org-get-heading t t t t)))
-			   "NONE")))))
-	   (setq link cpltxt)))))
+           (let ((here (org-link--file-link-to-here)))
+             (setq cpltxt (car here))
+             (setq desc (cdr here)))
+           (setq link cpltxt)))))
 
+       ;; Buffer linked to file, but not an org-mode buffer.
        ((buffer-file-name (buffer-base-buffer))
 	;; Just link to this file here.
-	(setq cpltxt (concat "file:"
-			     (abbreviate-file-name
-			      (buffer-file-name (buffer-base-buffer)))))
-	;; Add a context search string.
-	(when (org-xor org-link-context-for-files (equal arg '(4)))
-	  (let ((context (org-link--normalize-string
-			  (or (org-link--context-from-region)
-			      (org-current-line-string))
-			  t)))
-	    ;; Only use search option if there is some text.
-	    (when (org-string-nw-p context)
-	      (setq cpltxt (format "%s::%s" cpltxt context))
-	      (setq desc "NONE"))))
-	(setq link cpltxt))
+        (let ((here (org-link--file-link-to-here)))
+          (setq cpltxt (car here))
+          (setq desc (cdr here)))
+        (setq link cpltxt))
 
        (interactive?
 	(user-error "No method for storing a link from this buffer"))
@@ -1783,24 +1892,18 @@ non-nil."
       ;; Store and return the link
       (if (not (and interactive? link))
 	  (or agenda-link (and link (org-link-make-string link desc)))
-        (dotimes (_ (if custom-id 2 1)) ; Store 2 links when CUSTOM-ID is non-nil.
-          (cond
-           ((not (member (list link desc) org-stored-links))
-            (push (list link desc) org-stored-links)
-	    (message "Stored: %s" (or desc link)))
-           ((equal (list link desc) (car org-stored-links))
-            (message "This link has already been stored"))
-           (t
-            (setq org-stored-links
-                  (delete (list link desc) org-stored-links))
-            (push (list link desc) org-stored-links)
-            (message "Link moved to front: %s" (or desc link))))
-	  (when custom-id
-	    (setq link (concat "file:"
-			       (abbreviate-file-name
-			        (buffer-file-name (buffer-base-buffer)))
-			       "::#" custom-id))))
-	(car org-stored-links)))))
+        (org-link--add-to-stored-links link desc)
+        ;; In org buffers, store an additional "human-readable" link
+        ;; using custom id, if available.
+        (when (and (buffer-file-name (buffer-base-buffer))
+                   (derived-mode-p 'org-mode)
+                   (org-entry-get nil "CUSTOM_ID"))
+          (let ((here (org-link--file-link-to-here)))
+            (setq link (car here))
+            (setq desc (cdr here)))
+          (unless (equal (list link desc) (car org-stored-links))
+            (org-link--add-to-stored-links link desc)))
+        (car org-stored-links)))))
 
 ;;;###autoload
 (defun org-insert-link (&optional complete-file link-location description)
@@ -2094,6 +2197,39 @@ This command can be called in any mode to insert a link in Org syntax."
   (org-load-modules-maybe)
   (org-run-like-in-org-mode 'org-insert-link))
 
+(defun org--re-list-search-forward (regexp-list &optional bound noerror count)
+  "Like `re-search-forward', but REGEXP-LIST is a list of regexps.
+BOUND, NOERROR, and COUNT are passed to `re-search-forward'."
+  (let (result (min-found most-positive-fixnum)
+               (pos-found nil)
+               (min-found-data nil)
+               (tail regexp-list))
+    (while tail
+      (setq result (save-excursion (re-search-forward (pop tail) bound t count)))
+      (when (and result (< result min-found))
+        (setq min-found result
+              pos-found (match-end 0)
+              min-found-data (match-data))))
+    (if (= most-positive-fixnum min-found)
+        (pcase noerror
+          (`t nil)
+          (_ (re-search-forward (car regexp-list) bound noerror count)))
+      (set-match-data min-found-data)
+      (goto-char pos-found))))
+
+(defun org--re-list-looking-at (regexp-list &optional inhibit-modify)
+  "Like `looking-at', but REGEXP-LIST is a list of regexps.
+INHIBIT-MODIFY is passed to `looking-at'."
+  (catch :found
+    (while regexp-list
+      (when
+          (if inhibit-modify
+              (looking-at-p (pop regexp-list))
+            ;; FIXME: In Emacs <29, `looking-at' does not accept
+            ;; optional INHIBIT-MODIFY argument.
+            (looking-at (pop regexp-list)))
+        (throw :found t)))))
+
 ;;;###autoload
 (defun org-update-radio-target-regexp ()
   "Find all radio targets in this file and update the regular expression.
@@ -2131,6 +2267,30 @@ Also refresh fontification if needed."
 			targets
 			"\\|")
 		       after-re)))
+    (setq org-target-link-regexps nil)
+    (let (current-length sub-targets)
+      (when (<= org-target-link-regexp-limit (length org-target-link-regexp))
+        (while (or targets sub-targets)
+          (when (and sub-targets
+                     (or (not targets)
+                         (>= (+ current-length (length (car targets)))
+                            org-target-link-regexp-limit)))
+            (push (concat before-re
+                          (mapconcat
+			   (lambda (x)
+			     (replace-regexp-in-string
+			      " +" "\\s-+" (regexp-quote x) t t))
+			   (nreverse sub-targets)
+			   "\\|")
+		          after-re)
+                  org-target-link-regexps)
+            (setq current-length nil
+                  sub-targets nil))
+          (unless current-length
+            (setq current-length (+ (length before-re) (length after-re))))
+          (when targets (push (pop targets) sub-targets))
+          (cl-incf current-length (length (car sub-targets))))
+        (setq org-target-link-regexps (nreverse org-target-link-regexps))))
     (unless (equal old-regexp org-target-link-regexp)
       ;; Clean-up cache.
       (let ((regexp (cond ((not old-regexp) org-target-link-regexp)
@@ -2146,9 +2306,11 @@ Also refresh fontification if needed."
 				   after-re)))))
 	(when (and (featurep 'org-element)
                    (not (bound-and-true-p org-mode-loading)))
-	  (org-with-point-at 1
-	    (while (re-search-forward regexp nil t)
-	      (org-element-cache-refresh (match-beginning 1))))))
+          (if org-target-link-regexps
+              (org-element-cache-reset)
+	    (org-with-point-at 1
+	      (while (re-search-forward regexp nil t)
+	        (org-element-cache-refresh (match-beginning 1)))))))
       ;; Re fontify buffer.
       (when (memq 'radio org-highlight-links)
 	(org-restart-font-lock)))))

lisp/org-agenda.el

@@ -3148,169 +3148,172 @@ s   Search for keywords                 S   Like s, but only TODO entries
 					   '(face bold) header))
 		    header)))
 	(setq header-end (point-marker))
-	(while t
-	  (setq custom1 custom)
-	  (when (eq rmheader t)
-	    (org-goto-line 1)
-	    (re-search-forward ":" nil t)
-            (delete-region (match-end 0) (line-end-position))
-	    (forward-char 1)
-	    (looking-at "-+")
-            (delete-region (match-end 0) (line-end-position))
-	    (move-marker header-end (match-end 0)))
-	  (goto-char header-end)
-	  (delete-region (point) (point-max))
+        (unwind-protect
+	    (while t
+	      (setq custom1 custom)
+	      (when (eq rmheader t)
+	        (org-goto-line 1)
+	        (re-search-forward ":" nil t)
+                (delete-region (match-end 0) (line-end-position))
+	        (forward-char 1)
+	        (looking-at "-+")
+                (delete-region (match-end 0) (line-end-position))
+	        (move-marker header-end (match-end 0)))
+	      (goto-char header-end)
+	      (delete-region (point) (point-max))
 
-	  ;; Produce all the lines that describe custom commands and prefixes
-	  (setq lines nil)
-	  (while (setq entry (pop custom1))
-	    (setq key (car entry) desc (nth 1 entry)
-		  type (nth 2 entry)
-		  match (nth 3 entry))
-	    (if (> (length key) 1)
-		(cl-pushnew (string-to-char key) prefixes :test #'equal)
-	      (setq line
-		    (format
-		     "%-4s%-14s"
-		     (org-add-props (copy-sequence key)
-			 '(face bold))
-		     (cond
-		      ((string-match "\\S-" desc) desc)
-		      ((eq type 'agenda) "Agenda for current week or day")
-		      ((eq type 'agenda*) "Appointments for current week or day")
-		      ((eq type 'alltodo) "List of all TODO entries")
-		      ((eq type 'search) "Word search")
-		      ((eq type 'stuck) "List of stuck projects")
-		      ((eq type 'todo) "TODO keyword")
-		      ((eq type 'tags) "Tags query")
-		      ((eq type 'tags-todo) "Tags (TODO)")
-		      ((eq type 'tags-tree) "Tags tree")
-		      ((eq type 'todo-tree) "TODO kwd tree")
-		      ((eq type 'occur-tree) "Occur tree")
-		      ((functionp type) (if (symbolp type)
-					    (symbol-name type)
-					  "Lambda expression"))
-		      (t "???"))))
+	      ;; Produce all the lines that describe custom commands and prefixes
+	      (setq lines nil)
+	      (while (setq entry (pop custom1))
+	        (setq key (car entry) desc (nth 1 entry)
+		      type (nth 2 entry)
+		      match (nth 3 entry))
+	        (if (> (length key) 1)
+		    (cl-pushnew (string-to-char key) prefixes :test #'equal)
+	          (setq line
+		        (format
+		         "%-4s%-14s"
+		         (org-add-props (copy-sequence key)
+			     '(face bold))
+		         (cond
+		          ((string-match "\\S-" desc) desc)
+		          ((eq type 'agenda) "Agenda for current week or day")
+		          ((eq type 'agenda*) "Appointments for current week or day")
+		          ((eq type 'alltodo) "List of all TODO entries")
+		          ((eq type 'search) "Word search")
+		          ((eq type 'stuck) "List of stuck projects")
+		          ((eq type 'todo) "TODO keyword")
+		          ((eq type 'tags) "Tags query")
+		          ((eq type 'tags-todo) "Tags (TODO)")
+		          ((eq type 'tags-tree) "Tags tree")
+		          ((eq type 'todo-tree) "TODO kwd tree")
+		          ((eq type 'occur-tree) "Occur tree")
+		          ((functionp type) (if (symbolp type)
+					        (symbol-name type)
+					      "Lambda expression"))
+		          (t "???"))))
+	          (cond
+	           ((not (org-string-nw-p match)) nil)
+	           (org-agenda-menu-show-matcher
+		    (setq line
+		          (concat line ": "
+			          (cond
+			           ((stringp match)
+				    (propertize match 'face 'org-warning))
+			           ((listp type)
+				    (format "set of %d commands" (length type)))))))
+	           (t
+		    (org-add-props line nil 'help-echo (concat "Matcher: " match))))
+	          (push line lines)))
+	      (setq lines (nreverse lines))
+	      (when prefixes
+	        (mapc (lambda (x)
+		        (push
+		         (format "%s   %s"
+			         (org-add-props (char-to-string x)
+				     nil 'face 'bold)
+			         (or (cdr (assoc (concat selstring
+						         (char-to-string x))
+					         prefix-descriptions))
+				     "Prefix key"))
+		         lines))
+		      prefixes))
+
+	      ;; Check if we should display in two columns
+	      (if org-agenda-menu-two-columns
+	          (progn
+		    (setq n (length lines)
+		          n1 (+ (/ n 2) (mod n 2))
+		          right (nthcdr n1 lines)
+		          left (copy-sequence lines))
+		    (setcdr (nthcdr (1- n1) left) nil))
+	        (setq left lines right nil))
+	      (while left
+	        (insert "\n" (pop left))
+	        (when right
+	          (if (< (current-column) 40)
+		      (move-to-column 40 t)
+		    (insert "   "))
+	          (insert (pop right))))
+
+	      ;; Make the window the right size
+	      (goto-char (point-min))
+	      (if second-time
+	          (when (not (pos-visible-in-window-p (point-max)))
+		    (org-fit-window-to-buffer))
+	        (setq second-time t)
+	        (org-fit-window-to-buffer))
+
+	      ;; Hint to navigation if window too small for all information
+	      (setq header-line-format
+		    (when (not (pos-visible-in-window-p (point-max)))
+		      "Use C-v, M-v, C-n or C-p to navigate."))
+
+	      ;; Ask for selection
+	      (cl-loop
+	       do (progn
+		    (message "Press key for agenda command%s:"
+			     (if (or restrict-ok org-agenda-overriding-restriction)
+			         (if org-agenda-overriding-restriction
+				     " (restriction lock active)"
+			           (if restriction
+				       (format " (restricted to %s)" restriction)
+				     " (unrestricted)"))
+			       ""))
+		    (setq c (read-char-exclusive)))
+	       until (not (memq c '(14 16 22 134217846)))
+	       do (org-scroll c))
+
+	      (message "")
 	      (cond
-	       ((not (org-string-nw-p match)) nil)
-	       (org-agenda-menu-show-matcher
-		(setq line
-		      (concat line ": "
-			      (cond
-			       ((stringp match)
-				(propertize match 'face 'org-warning))
-			       ((listp type)
-				(format "set of %d commands" (length type)))))))
-	       (t
-		(org-add-props line nil 'help-echo (concat "Matcher: " match))))
-	      (push line lines)))
-	  (setq lines (nreverse lines))
-	  (when prefixes
-	    (mapc (lambda (x)
-		    (push
-		     (format "%s   %s"
-			     (org-add-props (char-to-string x)
-				 nil 'face 'bold)
-			     (or (cdr (assoc (concat selstring
-						     (char-to-string x))
-					     prefix-descriptions))
-				 "Prefix key"))
-		     lines))
-		  prefixes))
+	       ((assoc (char-to-string c) custom)
+	        (setq selstring (concat selstring (char-to-string c)))
+	        (throw 'exit (cons selstring restriction)))
+	       ((memq c prefixes)
+	        (setq selstring (concat selstring (char-to-string c))
+		      prefixes nil
+		      rmheader (or rmheader t)
+		      custom (delq nil (mapcar
+				      (lambda (x)
+				        (if (or (= (length (car x)) 1)
+					        (/= (string-to-char (car x)) c))
+					    nil
+				          (cons (substring (car x) 1) (cdr x))))
+				      custom))))
+	       ((eq c ?*)
+	        (call-interactively 'org-toggle-sticky-agenda)
+	        (sit-for 2))
+	       ((and (not restrict-ok) (memq c '(?1 ?0 ?<)))
+	        (message "Restriction is only possible in Org buffers")
+	        (ding) (sit-for 1))
+	       ((eq c ?1)
+	        (org-agenda-remove-restriction-lock 'noupdate)
+	        (setq restriction 'buffer))
+	       ((eq c ?0)
+	        (org-agenda-remove-restriction-lock 'noupdate)
+	        (setq restriction (if region-p 'region 'subtree)))
+	       ((eq c ?<)
+	        (org-agenda-remove-restriction-lock 'noupdate)
+	        (setq restriction
+		      (cond
+		       ((eq restriction 'buffer)
+		        (if region-p 'region 'subtree))
+		       ((memq restriction '(subtree region))
+		        nil)
+		       (t 'buffer))))
+	       ((eq c ?>)
+	        (org-agenda-remove-restriction-lock 'noupdate)
+	        (setq restriction nil))
+	       ((and (equal selstring "") (memq c '(?s ?S ?a ?t ?m ?L ?C ?e ?T ?M ?# ?! ?/ ??)))
+	        (throw 'exit (cons (setq selstring (char-to-string c)) restriction)))
+               ((and (> (length selstring) 0) (eq c ?\d))
+                (delete-window)
+                (org-agenda-get-restriction-and-command prefix-descriptions))
 
-	  ;; Check if we should display in two columns
-	  (if org-agenda-menu-two-columns
-	      (progn
-		(setq n (length lines)
-		      n1 (+ (/ n 2) (mod n 2))
-		      right (nthcdr n1 lines)
-		      left (copy-sequence lines))
-		(setcdr (nthcdr (1- n1) left) nil))
-	    (setq left lines right nil))
-	  (while left
-	    (insert "\n" (pop left))
-	    (when right
-	      (if (< (current-column) 40)
-		  (move-to-column 40 t)
-		(insert "   "))
-	      (insert (pop right))))
-
-	  ;; Make the window the right size
-	  (goto-char (point-min))
-	  (if second-time
-	      (when (not (pos-visible-in-window-p (point-max)))
-		(org-fit-window-to-buffer))
-	    (setq second-time t)
-	    (org-fit-window-to-buffer))
-
-	  ;; Hint to navigation if window too small for all information
-	  (setq header-line-format
-		(when (not (pos-visible-in-window-p (point-max)))
-		  "Use C-v, M-v, C-n or C-p to navigate."))
-
-	  ;; Ask for selection
-	  (cl-loop
-	   do (progn
-		(message "Press key for agenda command%s:"
-			 (if (or restrict-ok org-agenda-overriding-restriction)
-			     (if org-agenda-overriding-restriction
-				 " (restriction lock active)"
-			       (if restriction
-				   (format " (restricted to %s)" restriction)
-				 " (unrestricted)"))
-			   ""))
-		(setq c (read-char-exclusive)))
-	   until (not (memq c '(14 16 22 134217846)))
-	   do (org-scroll c))
-
-	  (message "")
-	  (cond
-	   ((assoc (char-to-string c) custom)
-	    (setq selstring (concat selstring (char-to-string c)))
-	    (throw 'exit (cons selstring restriction)))
-	   ((memq c prefixes)
-	    (setq selstring (concat selstring (char-to-string c))
-		  prefixes nil
-		  rmheader (or rmheader t)
-		  custom (delq nil (mapcar
-				    (lambda (x)
-				      (if (or (= (length (car x)) 1)
-					      (/= (string-to-char (car x)) c))
-					  nil
-					(cons (substring (car x) 1) (cdr x))))
-				    custom))))
-	   ((eq c ?*)
-	    (call-interactively 'org-toggle-sticky-agenda)
-	    (sit-for 2))
-	   ((and (not restrict-ok) (memq c '(?1 ?0 ?<)))
-	    (message "Restriction is only possible in Org buffers")
-	    (ding) (sit-for 1))
-	   ((eq c ?1)
-	    (org-agenda-remove-restriction-lock 'noupdate)
-	    (setq restriction 'buffer))
-	   ((eq c ?0)
-	    (org-agenda-remove-restriction-lock 'noupdate)
-	    (setq restriction (if region-p 'region 'subtree)))
-	   ((eq c ?<)
-	    (org-agenda-remove-restriction-lock 'noupdate)
-	    (setq restriction
-		  (cond
-		   ((eq restriction 'buffer)
-		    (if region-p 'region 'subtree))
-		   ((memq restriction '(subtree region))
-		    nil)
-		   (t 'buffer))))
-	   ((eq c ?>)
-	    (org-agenda-remove-restriction-lock 'noupdate)
-	    (setq restriction nil))
-	   ((and (equal selstring "") (memq c '(?s ?S ?a ?t ?m ?L ?C ?e ?T ?M ?# ?! ?/ ??)))
-	    (throw 'exit (cons (setq selstring (char-to-string c)) restriction)))
-           ((and (> (length selstring) 0) (eq c ?\d))
-            (delete-window)
-            (org-agenda-get-restriction-and-command prefix-descriptions))
-
-	   ((equal c ?q) (user-error "Abort"))
-	   (t (user-error "Invalid key %c" c))))))))
+	       ((equal c ?q) (user-error "Abort"))
+	       (t (user-error "Invalid key %c" c))))
+          ;; Close  *Agenda Commands* window.
+          (quit-window))))))
 
 (defun org-agenda-fit-window-to-buffer ()
   "Fit the window to the buffer size."
@@ -3638,11 +3641,12 @@ the agenda to write."
 		  (goto-char p)
 		  (setq m (get-text-property (point) 'org-hd-marker))
 		  (when m
-		    (push (with-current-buffer (marker-buffer m)
-			    (goto-char m)
-			    (org-copy-subtree 1 nil t t)
-			    org-subtree-clip)
-			  content)))
+		    (cl-pushnew (with-current-buffer (marker-buffer m)
+			          (goto-char m)
+			          (org-copy-subtree 1 nil t t)
+			          org-subtree-clip)
+			        content
+                                :test #'equal)))
 		(find-file file)
 		(erase-buffer)
 		(dolist (s content) (org-paste-subtree 1 s))
@@ -6399,14 +6403,14 @@ specification like [h]h:mm."
 		       (org-agenda--timestamp-to-absolute
 		        s base 'future (current-buffer) pos)))))
 	          (diff (- deadline current))
-	          (suppress-prewarning
+	          (max-warning-days
 		   (let ((scheduled
 		          (and org-agenda-skip-deadline-prewarning-if-scheduled
                                (org-element-property
                                 :raw-value
                                 (org-element-property :scheduled el)))))
 		     (cond
-		      ((not scheduled) nil)
+		      ((not scheduled) most-positive-fixnum)
 		      ;; The current item has a scheduled date, so
 		      ;; evaluate its prewarning lead time.
 		      ((integerp org-agenda-skip-deadline-prewarning-if-scheduled)
@@ -6420,15 +6424,15 @@ specification like [h]h:mm."
 			    org-deadline-warning-days))
 		      ;; Set pre-warning to deadline.
 		      (t 0))))
-	          (wdays (or suppress-prewarning (org-get-wdays s))))
+	          (warning-days (min max-warning-days (org-get-wdays s))))
 	     (cond
 	      ;; Only display deadlines at their base date, at future
 	      ;; repeat occurrences or in today agenda.
 	      ((= current deadline) nil)
 	      ((= current repeat) nil)
 	      ((not today?) (throw :skip nil))
-	      ;; Upcoming deadline: display within warning period WDAYS.
-	      ((> deadline current) (when (> diff wdays) (throw :skip nil)))
+	      ;; Upcoming deadline: display within warning period WARNING-DAYS.
+	      ((> deadline current) (when (> diff warning-days) (throw :skip nil)))
 	      ;; Overdue deadline: warn about it for
 	      ;; `org-deadline-past-days' duration.
 	      (t (when (< org-deadline-past-days (- diff)) (throw :skip nil))))
@@ -6481,7 +6485,7 @@ specification like [h]h:mm."
                           'effort-minutes effort-minutes)
                         level category tags time))
 		      (face (org-agenda-deadline-face
-			     (- 1 (/ (float diff) (max wdays 1)))))
+			     (- 1 (/ (float diff) (max warning-days 1)))))
 		      (upcoming? (and today? (> deadline today)))
 		      (warntime (org-entry-get (point) "APPT_WARNTIME" 'selective)))
 	         (org-add-props item props
@@ -6610,13 +6614,13 @@ scheduled items with an hour specification like [h]h:mm."
 	          (futureschedp (> schedule today))
 	          (habitp (and (fboundp 'org-is-habit-p)
                                (string= "habit" (org-element-property :STYLE el))))
-	          (suppress-delay
+	          (max-delay-days
 		   (let ((deadline (and org-agenda-skip-scheduled-delay-if-deadline
                                         (org-element-property
                                          :raw-value
                                          (org-element-property :deadline el)))))
 		     (cond
-		      ((not deadline) nil)
+		      ((not deadline) most-positive-fixnum)
 		      ;; The current item has a deadline date, so
 		      ;; evaluate its delay time.
 		      ((integerp org-agenda-skip-scheduled-delay-if-deadline)
@@ -6629,17 +6633,14 @@ scheduled items with an hour specification like [h]h:mm."
 			       (org-agenda--timestamp-to-absolute deadline))
 			    org-scheduled-delay-days))
 		      (t 0))))
-	          (ddays
+	          (delay-days
 		   (cond
 		    ;; Nullify delay when a repeater triggered already
 		    ;; and the delay is of the form --Xd.
 		    ((and (string-match-p "--[0-9]+[hdwmy]" s)
 		          (> schedule (org-agenda--timestamp-to-absolute s)))
 		     0)
-		    (suppress-delay
-		     (let ((org-scheduled-delay-days suppress-delay))
-		       (org-get-wdays s t t)))
-		    (t (org-get-wdays s t)))))
+		    (t (min max-delay-days (org-get-wdays s t))))))
 	     ;; Display scheduled items at base date (SCHEDULE), today if
 	     ;; scheduled before the current date, and at any repeat past
 	     ;; today.  However, skip delayed items and items that have
@@ -6647,7 +6648,7 @@ scheduled items with an hour specification like [h]h:mm."
 	     (unless (and todayp
 		          habitp
 		          (bound-and-true-p org-habit-show-all-today))
-	       (when (or (and (> ddays 0) (< diff ddays))
+	       (when (or (and (> delay-days 0) (< diff delay-days))
 		         (> diff (or (and habitp org-habit-scheduled-past-days)
 				     org-scheduled-past-days))
 		         (> schedule current)
@@ -6966,6 +6967,7 @@ Any match of REMOVE-RE will be removed from TXT."
 			       (file-name-sans-extension
 				(file-name-nondirectory buffer-file-name))
 			     "")))
+             (full-category category)
 	     (category-icon (org-agenda-get-category-icon category))
 	     (category-icon (if category-icon
 				(propertize " " 'display category-icon)
@@ -7093,7 +7095,9 @@ Any match of REMOVE-RE will be removed from TXT."
 	;; And finally add the text properties
 	(remove-text-properties 0 (length rtn) '(line-prefix t wrap-prefix t) rtn)
 	(org-add-props rtn nil
-	  'org-category category
+          ;; CATEGORY might be truncated.  Store the full category in
+          ;; the properties.
+	  'org-category full-category
           'tags tags
           'org-priority-highest org-priority-highest
 	  'org-priority-lowest org-priority-lowest

lisp/org-archive.el

@@ -157,7 +157,7 @@ archive location, but not yet deleted from the original file.")
   "Splice the archive FILES into the list of files.
 This implies visiting all these files and finding out what the
 archive file is."
-  (org-uniquify
+  (seq-uniq
    (apply
     'append
     (mapcar
@@ -166,7 +166,9 @@ archive file is."
 	   nil
 	 (with-current-buffer (org-get-agenda-file-buffer f)
 	   (cons f (org-all-archive-files)))))
-     files))))
+     files))
+   #'file-equal-p
+   ))
 
 (defun org-all-archive-files ()
   "List of all archive files used in the current buffer."

lisp/org-capture.el

@@ -995,7 +995,7 @@ Store them in the capture property list."
 	((or `here
              `(here))
 	 (org-capture-put :exact-position (point) :insert-here t))
-	(`(file ,(and path (pred stringp)))
+	(`(file ,path)
 	 (set-buffer (org-capture-target-buffer path))
 	 (org-capture-put-target-region-and-position)
 	 (widen)
@@ -1008,7 +1008,7 @@ Store them in the capture property list."
 	    (org-capture-put-target-region-and-position)
 	    (goto-char position))
 	   (_ (error "Cannot find target ID \"%s\"" id))))
-	(`(file+headline ,(and path (pred stringp)) ,(and headline (pred stringp)))
+	(`(file+headline ,path ,(and headline (pred stringp)))
 	 (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
@@ -1030,7 +1030,7 @@ Store them in the capture property list."
 	   (unless (bolp) (insert "\n"))
 	   (insert "* " headline "\n")
 	   (forward-line -1)))
-	(`(file+olp ,(and path (pred stringp)) . ,(and outline-path (guard outline-path)))
+	(`(file+olp ,path . ,(and outline-path (guard outline-path)))
 	 (let ((m (org-find-olp (cons (org-capture-expand-file path)
 				      outline-path))))
 	   (set-buffer (marker-buffer m))
@@ -1038,7 +1038,7 @@ Store them in the capture property list."
 	   (widen)
 	   (goto-char m)
 	   (set-marker m nil)))
-	(`(file+regexp ,(and path (pred stringp)) ,(and regexp (pred stringp)))
+	(`(file+regexp ,path ,(and regexp (pred stringp)))
 	 (set-buffer (org-capture-target-buffer path))
 	 (org-capture-put-target-region-and-position)
 	 (widen)
@@ -1051,7 +1051,7 @@ Store them in the capture property list."
 	   (org-capture-put :exact-position (point))
 	   (setq target-entry-p
 		 (and (derived-mode-p 'org-mode) (org-at-heading-p)))))
-	(`(file+olp+datetree ,(and path (pred stringp)) . ,outline-path)
+	(`(file+olp+datetree ,path . ,outline-path)
 	 (let ((m (if outline-path
 		      (org-find-olp (cons (org-capture-expand-file path)
 					  outline-path))
@@ -1106,7 +1106,7 @@ Store them in the capture property list."
 	    ;; the following is the keep-restriction argument for
 	    ;; org-datetree-find-date-create
 	    (when outline-path 'subtree-at-point))))
-	(`(file+function ,(and path (pred stringp)) ,(and function (pred functionp)))
+	(`(file+function ,path ,(and function (pred functionp)))
 	 (set-buffer (org-capture-target-buffer path))
 	 (org-capture-put-target-region-and-position)
 	 (widen)
@@ -1508,7 +1508,7 @@ Of course, if exact position has been required, just put it there."
               (condition-case err
 	          (bookmark-set bookmark)
                 (error
-                 (message (format "Bookmark set error: %S" err)))))))
+                 (message "Bookmark set error: %S" err))))))
 	(move-marker org-capture-last-stored-marker (point))))))
 
 (defun org-capture-narrow (beg end)

lisp/org-colview.el

@@ -1253,9 +1253,9 @@ properties drawers."
 	   ;; property `org-summaries', in alist whose key is SPEC.
 	   (let* ((summary
 		   (and summarize
-			(let ((values (append (and (/= last-level inminlevel)
-						   (aref lvals last-level))
-					      (aref lvals inminlevel))))
+			(let ((values
+                               (cl-loop for l from (1+ level) to lmax
+                                        append (aref lvals l))))
 			  (and values (funcall summarize values printf))))))
 	     ;; Leaf values are not summaries: do not mark them.
 	     (when summary

lisp/org-crypt.el

@@ -246,7 +246,7 @@ Assume `epg-context' is set."
 	     ;; contents in the buffer.
 	     (error
 	      (insert contents)
-	      (error (error-message-string err)))))
+	      (error "%s" (error-message-string err)))))
 	 (when folded-heading
 	   (goto-char folded-heading)
 	   (org-fold-subtree t))

lisp/org-cycle.el

@@ -116,6 +116,7 @@ than its value."
 	  (const :tag "No limit" nil)
 	  (integer :tag "Maximum level")))
 
+(defvaralias 'org-hide-block-startup 'org-cycle-hide-block-startup)
 (defcustom org-cycle-hide-block-startup nil
   "Non-nil means entering Org mode will fold all blocks.
 This can also be set in on a per-file basis with
@@ -126,6 +127,7 @@ This can also be set in on a per-file basis with
   :group 'org-cycle
   :type 'boolean)
 
+(defvaralias 'org-hide-drawer-startup 'org-cycle-hide-drawer-startup)
 (defcustom org-cycle-hide-drawer-startup t
   "Non-nil means entering Org mode will fold all drawers.
 This can also be set in on a per-file basis with
@@ -201,6 +203,7 @@ Special case: when 0, never leave empty lines in collapsed view."
   :type 'integer)
 (put 'org-cycle-separator-lines 'safe-local-variable 'integerp)
 
+(defvaralias 'org-pre-cycle-hook 'org-cycle-pre-hook)
 (defcustom org-cycle-pre-hook nil
   "Hook that is run before visibility cycling is happening.
 The function(s) in this hook must accept a single argument which indicates
@@ -241,6 +244,7 @@ normal outline commands like `show-all', but not with the cycling commands."
   :package-version '(Org . "9.6")
   :type 'boolean)
 
+(defvaralias 'org-tab-first-hook 'org-cycle-tab-first-hook)
 (defvar org-cycle-tab-first-hook nil
   "Hook for functions to attach themselves to TAB.
 See `org-ctrl-c-ctrl-c-hook' for more information.

lisp/org-element-ast.el

@@ -1131,8 +1131,11 @@ The function takes care of setting `:parent' property for NEW."
 	    (eq new-type 'plain-text))
         ;; We cannot replace OLD with NEW since strings are not mutable.
         ;; We take the long path.
-        (progn (org-element-insert-before new old)
-	       (org-element-extract old))
+        (progn
+          (org-element-insert-before new old)
+	  (org-element-extract old)
+          ;; We will return OLD.
+          (setq old new))
       ;; Since OLD is going to be changed into NEW by side-effect, first
       ;; make sure that every element or object within NEW has OLD as
       ;; parent.

lisp/org-element.el

@@ -551,6 +551,8 @@ The resulting function can be evaluated at a later time, from
 another buffer, effectively cloning the original buffer there.
 
 The function assumes BUFFER's major mode is `org-mode'."
+  (declare-function org-fold-core--update-buffer-folds "org-fold-core" ())
+  (require 'org-fold-core)
   (with-current-buffer buffer
     (let ((str (unless drop-contents (org-with-wide-buffer (buffer-string))))
           (narrowing
@@ -592,7 +594,7 @@ The function assumes BUFFER's major mode is `org-mode'."
 	         (let ((invis-prop (overlay-get ov 'invisible)))
 		   (when invis-prop
 		     (push (list (overlay-start ov) (overlay-end ov)
-			         invis-prop)
+			         (overlay-properties ov))
 			   ov-set))))
 	       ov-set))))
       (lambda ()
@@ -618,8 +620,12 @@ The function assumes BUFFER's major mode is `org-mode'."
 	  ;; Current position of point.
 	  (goto-char pos)
 	  ;; Overlays with invisible property.
-	  (pcase-dolist (`(,start ,end ,invis) ols)
-	    (overlay-put (make-overlay start end) 'invisible invis))
+	  (pcase-dolist (`(,start ,end ,props) ols)
+            (let ((ov (make-overlay start end)))
+              (while props
+                (overlay-put ov (pop props) (pop props)))))
+          ;; Text property folds.
+          (unless drop-visibility (org-fold-core--update-buffer-folds))
           ;; Never write the buffer copy to disk, despite
           ;; `buffer-file-name' not being nil.
           (setq write-contents-functions (list (lambda (&rest _) t))))))))
@@ -3842,7 +3848,9 @@ Assume point is at the beginning of the link."
        ;; Type 1: Text targeted from a radio target.
        ((and org-target-link-regexp
 	     (save-excursion (or (bolp) (backward-char))
-			     (looking-at org-target-link-regexp)))
+                             (if org-target-link-regexps
+                                 (org--re-list-looking-at org-target-link-regexps)
+                               (looking-at org-target-link-regexp))))
 	(setq type "radio")
 	(setq format 'plain)
 	(setq link-end (match-end 1))
@@ -5215,7 +5223,10 @@ to an appropriate container (e.g., a paragraph)."
 		       ((not (memq 'link restriction)) nil)
 		       ((progn
 		          (unless (bolp) (forward-char -1))
-		          (not (re-search-forward org-target-link-regexp nil t)))
+		          (not
+                           (if org-target-link-regexps
+                               (org--re-list-search-forward org-target-link-regexps nil t)
+                             (re-search-forward org-target-link-regexp nil t))))
 		        nil)
 		       ;; Since we moved backward, we do not want to
 		       ;; match again an hypothetical 1-character long
@@ -5224,8 +5235,11 @@ to an appropriate container (e.g., a paragraph)."
 		       ;; beginning of line, we prevent this here.
 		       ((and (= start (1+ (line-beginning-position)))
 			     (= start (match-end 1)))
-		        (and (re-search-forward org-target-link-regexp nil t)
-			     (1+ (match-beginning 1))))
+		        (and
+                         (if org-target-link-regexps
+                             (org--re-list-search-forward org-target-link-regexps nil t)
+                           (re-search-forward org-target-link-regexp nil t))
+			 (1+ (match-beginning 1))))
 		       (t (1+ (match-beginning 1))))))
 	      found)
          (save-excursion

lisp/org-entities.el

@@ -29,6 +29,7 @@
 
 (require 'org-macs)
 (org-assert-version)
+(require 'seq) ; Emacs 27 does not preload seq.el; for `seq-every-p'.
 
 (declare-function org-mode "org" ())
 (declare-function org-toggle-pretty-entities "org"       ())

lisp/org-fold-core.el

@@ -634,6 +634,10 @@ unless RETURN-ONLY is non-nil."
                                                 text-property-default-nonsticky
                                                 full-prop-list))))))))))))))
 
+(defun org-fold-core--update-buffer-folds ()
+  "Copy folding state in a new buffer with text copied from old buffer."
+  (org-fold-core--property-symbol-get-create (car (org-fold-core-folding-spec-list))))
+
 (defun org-fold-core-decouple-indirect-buffer-folds ()
   "Copy and decouple folding state in a newly created indirect buffer.
 This function is mostly intended to be used in
@@ -641,7 +645,7 @@ This function is mostly intended to be used in
   (when (and (buffer-base-buffer)
              (eq org-fold-core-style 'text-properties)
              (not (memql 'ignore-indirect org-fold-core--optimise-for-huge-buffers)))
-    (org-fold-core--property-symbol-get-create (car (org-fold-core-folding-spec-list)))))
+    (org-fold-core--update-buffer-folds)))
 
 ;;; API
 
@@ -784,19 +788,16 @@ corresponding folding spec (if the text is folded using that spec)."
     (when (and spec (not (eq spec 'all))) (org-fold-core--check-spec spec))
     (org-with-point-at pom
       (cond
-       ((eq spec 'all)
-        (let ((result))
-	  (dolist (spec (org-fold-core-folding-spec-list))
-	    (let ((val (if (eq org-fold-core-style 'text-properties)
-                           (get-text-property (point) (org-fold-core--property-symbol-get-create spec nil t))
-                         (get-char-property (point) (org-fold-core--property-symbol-get-create spec nil t)))))
-	      (when val (push val result))))
-          (reverse result)))
-       ((null spec)
-        (let ((result (if (eq org-fold-core-style 'text-properties)
-                          (get-text-property (point) 'invisible)
-                        (get-char-property (point) 'invisible))))
-          (when (org-fold-core-folding-spec-p result) result)))
+       ((or (null spec) (eq spec 'all))
+        (catch :single-spec
+          (let ((result))
+	    (dolist (lspec (org-fold-core-folding-spec-list))
+	      (let ((val (if (eq org-fold-core-style 'text-properties)
+                             (get-text-property (point) (org-fold-core--property-symbol-get-create lspec nil t))
+                           (get-char-property (point) (org-fold-core--property-symbol-get-create lspec nil t)))))
+                (when (and val (null spec)) (throw :single-spec val))
+	        (when val (push val result))))
+            (reverse result))))
        (t (if (eq org-fold-core-style 'text-properties)
               (get-text-property (point) (org-fold-core--property-symbol-get-create spec nil t))
             (get-char-property (point) (org-fold-core--property-symbol-get-create spec nil t))))))))
@@ -1034,26 +1035,23 @@ If SPEC-OR-ALIAS is omitted and FLAG is nil, unfold everything in the region."
     (when spec (org-fold-core--check-spec spec))
     (with-silent-modifications
       (org-with-wide-buffer
-       ;; Arrange face property of newlines after all the folds
-       ;; between FROM and TO to match the first character before the
-       ;; fold; not the last as per Emacs defaults.  This makes
-       ;; :extend faces span past the ellipsis.
-       ;; See bug#65896.
-       (if flag ; folding
-           (when (equal ?\n (char-after to))
-             (put-text-property to (1+ to) 'face (get-text-property from 'face)))
-         ;; unfolding
-         (dolist (region (org-fold-core-get-regions :from from :to to :specs spec))
-           (when (equal ?\n (char-after (cadr region)))
-             (if-let ((specs (remq spec (org-fold-core-get-folding-spec 'all (1- (cadr region))))))
-                 ;; There are multiple folds, re-apply 'face according
-                 ;; to the folds that will stay after unfolding SPEC.
-                 (put-text-property
-                  (cadr region) (1+ (cadr region)) 'face
-                  (get-text-property
-                   (car (org-fold-core-get-region-at-point (car specs) (1- (cadr region))))
-                   'face))
-               (font-lock-flush (cadr region) (1+ (cadr region)))))))
+       ;; Arrange fontifying newlines after all the folds between FROM
+       ;; and TO to match the first character before the fold; not the
+       ;; last as per Emacs defaults.  This makes :extend faces span
+       ;; past the ellipsis.  See bug#65896.  The face properties are
+       ;; assigned via `org-activate-folds'.
+       (when (equal ?\n (char-after from))
+         (font-lock-flush from (1+ from)))
+       (when (equal ?\n (char-after to))
+         (font-lock-flush to (1+ to)))
+       (dolist (region (org-fold-core-get-regions :from from :to to :specs spec))
+         (when (equal ?\n (char-after (cadr region)))
+           (font-lock-flush (cadr region) (1+ (cadr region))))
+         ;; Re-fontify beginning of the fold - we may
+         ;; unfold inside an existing fold, with FROM begin a newline
+         ;; after spliced fold.
+         (when (equal ?\n (char-after (car region)))
+           (font-lock-flush (car region) (1+ (car region)))))
        (when (eq org-fold-core-style 'overlays)
          (if org-fold-core--keep-overlays
              (mapc
@@ -1113,14 +1111,12 @@ If SPEC-OR-ALIAS is omitted and FLAG is nil, unfold everything in the region."
                          (setq pos next))
                      (setq pos (next-single-char-property-change pos 'invisible nil to)))))))
            (when (eq org-fold-core-style 'text-properties)
-	     (remove-text-properties from to (list (org-fold-core--property-symbol-get-create spec) nil)))
-           ;; FROM..TO may represent only a part of the fold.  Transfer
-           ;; 'face from the new char before fold, if there is any.
-           (when-let ((trailing-fold (org-fold-core-get-region-at-point spec to)))
-             (when (equal ?\n (char-after (cdr trailing-fold)))
-               (put-text-property
-                (cdr trailing-fold) (1+ (cdr trailing-fold))
-                'face (get-text-property to 'face))))))))))
+	     (remove-text-properties from to (list (org-fold-core--property-symbol-get-create spec) nil)))))
+       ;; Re-calculate trailing faces for all the folds revealed
+       ;; by unfolding or created by folding.
+       (dolist (region (org-fold-core-get-regions :from from :to to :specs spec))
+         (when (equal ?\n (char-after (cadr region)))
+           (font-lock-flush (cadr region) (1+ (cadr region)))))))))
 
 (cl-defmacro org-fold-core-regions (regions &key override clean-markers relative)
   "Fold every region in REGIONS list in current buffer.

lisp/org-goto.el

@@ -102,7 +102,11 @@ When nil, you can use these keybindings to navigate the buffer:
 					mouse-drag-region universal-argument org-occur)))
 	    (dolist (cmd cmds)
 	      (substitute-key-definition cmd cmd map global-map)))
-	  (suppress-keymap map)
+	  (if org-goto-auto-isearch
+              ;; Suppress 0-9 interpreted as digital arguments.
+              ;; Make them initiate isearch instead.
+              (suppress-keymap map t)
+            (suppress-keymap map))
 	  (org-defkey map "\C-m"     'org-goto-ret)
 	  (org-defkey map [(return)] 'org-goto-ret)
 	  (org-defkey map [(left)]   'org-goto-left)

lisp/org-id.el

@@ -129,6 +129,46 @@ nil   Never use an ID to make a link, instead link using a text search for
 	  (const :tag "Only use existing" use-existing)
 	  (const :tag "Do not use ID to create link" nil)))
 
+(defcustom org-id-link-consider-parent-id nil
+  "Non-nil means storing a link to an Org entry considers inherited IDs.
+
+When this option is non-nil and `org-id-link-use-context' is
+enabled, ID properties inherited from parent entries will be
+considered when storing an ID link.  If no ID is found in this
+way, a new one may be created as normal (see
+`org-id-link-to-org-use-id').
+
+For example, given this org file:
+
+* Parent
+:PROPERTIES:
+:ID: abc
+:END:
+** Child 1
+** Child 2
+
+With `org-id-link-consider-parent-id' and
+`org-id-link-use-context' both enabled, storing a link with point
+at \"Child 1\" will produce a link \"<id:abc::*Child 1>\".  This
+allows linking to uniquely-named sub-entries within a parent
+entry with an ID, without requiring every sub-entry to have its
+own ID."
+  :group 'org-link-store
+  :group 'org-id
+  :package-version '(Org . "9.7")
+  :type 'boolean)
+
+(defcustom org-id-link-use-context t
+  "Non-nil means enables search string context in org-id links.
+
+Search strings are added by `org-id-store-link' when both the
+general option `org-link-context-for-files' and the org-id option
+`org-id-link-use-context' are non-nil."
+  :group 'org-link-store
+  :group 'org-id
+  :package-version '(Org . "9.7")
+  :type 'boolean)
+
 (defcustom org-id-uuid-program "uuidgen"
   "The uuidgen program."
   :group 'org-id
@@ -280,15 +320,21 @@ This is useful when working with contents in a temporary buffer
 that will be copied back to the original.")
 
 ;;;###autoload
-(defun org-id-get (&optional epom create prefix)
-  "Get the ID property of the entry at EPOM.
-EPOM is an element, marker, or buffer position.
-If EPOM is nil, refer to the entry at point.
-If the entry does not have an ID, the function returns nil.
-However, when CREATE is non-nil, create an ID if none is present already.
-PREFIX will be passed through to `org-id-new'.
-In any case, the ID of the entry is returned."
-  (let ((id (org-entry-get epom "ID")))
+(defun org-id-get (&optional epom create prefix inherit)
+  "Get the ID of the entry at EPOM.
+
+EPOM is an element, marker, or buffer position.  If EPOM is nil,
+refer to the entry at point.
+
+If INHERIT is non-nil, ID properties inherited from parent
+entries are considered.  Otherwise, only ID properties on the
+entry itself are considered.
+
+When CREATE is nil, return the ID of the entry if found,
+otherwise nil.  When CREATE is non-nil, create an ID if none has
+been found, and return the new ID.  PREFIX will be passed through
+to `org-id-new'."
+  (let ((id (org-entry-get epom "ID" (and inherit t))))
     (cond
      ((and id (stringp id) (string-match "\\S-" id))
       id)
@@ -700,21 +746,56 @@ optional argument MARKERP, return the position as a new marker."
 
 ;; id link type
 
-;; Calling the following function is hard-coded into `org-store-link',
-;; so we do have to add it to `org-store-link-functions'.
+(defun org-id--get-id-to-store-link (&optional create)
+  "Get or create the relevant ID for storing a link.
+
+Optional argument CREATE is passed to `org-id-get'.
+
+Inherited IDs are only considered when
+`org-id-link-consider-parent-id', `org-id-link-use-context' and
+`org-link-context-for-files' are all enabled, since inherited IDs
+are confusing without the additional search string context.
+
+Note that this function resets the
+`org-entry-property-inherited-from' marker: it will either point
+to nil (if the id was not inherited) or to the point it was
+inherited from."
+  (let* ((inherit-id (and org-id-link-consider-parent-id
+                          org-id-link-use-context
+                          org-link-context-for-files)))
+    (move-marker org-entry-property-inherited-from nil)
+    (org-id-get nil create nil inherit-id)))
 
 ;;;###autoload
 (defun org-id-store-link ()
   "Store a link to the current entry, using its ID.
 
-If before first heading store first title-keyword as description
-or filename if no title."
+The link description is based on the heading, or if before the
+first heading, the title keyword if available, or else the
+filename.
+
+When `org-link-context-for-files' and `org-id-link-use-context'
+are non-nil, add a search string to the link.  The link
+description is then based on the search string target.
+
+When in addition `org-id-link-consider-parent-id' is non-nil, the
+ID can be inherited from a parent entry, with the search string
+used to still link to the current location."
   (interactive)
-  (when (and (buffer-file-name (buffer-base-buffer)) (derived-mode-p 'org-mode))
-    (let* ((link (concat "id:" (org-id-get-create)))
+  (when (and (buffer-file-name (buffer-base-buffer))
+             (derived-mode-p 'org-mode))
+    ;; Get the precise target first, in case looking for an id causes
+    ;; a properties drawer to be added at the current location.
+    (let* ((precise-target (and org-link-context-for-files
+                                org-id-link-use-context
+                                (org-link-precise-link-target)))
+           (link (concat "id:" (org-id--get-id-to-store-link 'create)))
+           (id-location (or (and org-entry-property-inherited-from
+                                 (marker-position org-entry-property-inherited-from))
+                            (save-excursion (org-back-to-heading-or-point-min t) (point))))
 	   (case-fold-search nil)
 	   (desc (save-excursion
-		   (org-back-to-heading-or-point-min t)
+                   (goto-char id-location)
                    (cond ((org-before-first-heading-p)
                           (let ((keywords (org-collect-keywords '("TITLE"))))
                             (if keywords
@@ -726,14 +807,59 @@ or filename if no title."
 			      (match-string 4)
 			    (match-string 0)))
                          (t link)))))
+      ;; Precise targets should be after id-location to avoid
+      ;; duplicating the current headline as a search string
+      (when (and precise-target
+                 (> (nth 2 precise-target) id-location))
+         (setq link (concat link "::" (nth 0 precise-target)))
+         (setq desc (nth 1 precise-target)))
       (org-link-store-props :link link :description desc :type "id")
       link)))
 
-(defun org-id-open (id _)
-  "Go to the entry with id ID."
-  (org-mark-ring-push)
-  (let ((m (org-id-find id 'marker))
-	cmd)
+;;;###autoload
+(defun org-id-store-link-maybe (&optional interactive?)
+  "Store a link to the current entry using its ID if enabled.
+
+The value of `org-id-link-to-org-use-id' determines whether an ID
+link should be stored, using `org-id-store-link'.
+
+Assume the function is called interactively if INTERACTIVE? is
+non-nil."
+  (when (and (buffer-file-name (buffer-base-buffer))
+             (derived-mode-p 'org-mode)
+             (or (eq org-id-link-to-org-use-id t)
+                 (and interactive?
+                      (or (eq org-id-link-to-org-use-id 'create-if-interactive)
+                          (and (eq org-id-link-to-org-use-id
+                                   'create-if-interactive-and-no-custom-id)
+                               (not (org-entry-get nil "CUSTOM_ID")))))
+                 ;; 'use-existing
+                 (and org-id-link-to-org-use-id
+                      (org-id--get-id-to-store-link))))
+    (org-id-store-link)))
+
+(defun org-id-open (link _)
+  "Go to the entry indicated by id link LINK.
+
+The link can include a search string after \"::\", which is
+passed to `org-link-search'.
+
+For backwards compatibility with IDs that contain \"::\", if no
+match is found for the ID, the full link string including \"::\"
+will be tried as an ID."
+  (let* ((option (and (string-match "::\\(.*\\)\\'" link)
+		      (match-string 1 link)))
+	 (id (if (not option) link
+               (substring link 0 (match-beginning 0))))
+         m cmd)
+    (org-mark-ring-push)
+    (setq m (org-id-find id 'marker))
+    (when (and (not m) option)
+      ;; Backwards compatibility: if id is not found, try treating
+      ;; whole link as an id.
+      (setq m (org-id-find link 'marker))
+      (when m
+        (setq option nil)))
     (unless m
       (error "Cannot find entry with ID \"%s\"" id))
     ;; Use a buffer-switching command in analogy to finding files
@@ -750,9 +876,17 @@ or filename if no title."
 	(funcall cmd (marker-buffer m)))
     (goto-char m)
     (move-marker m nil)
+    (when option
+      (save-restriction
+        (unless (org-before-first-heading-p)
+          (org-narrow-to-subtree))
+        (org-link-search option nil nil
+                         (org-element-lineage (org-element-at-point) 'headline t))))
     (org-fold-show-context)))
 
-(org-link-set-parameters "id" :follow #'org-id-open)
+(org-link-set-parameters "id"
+  :follow #'org-id-open
+  :store #'org-id-store-link-maybe)
 
 (provide 'org-id)
 

lisp/org-lint.el

@@ -65,6 +65,7 @@
 ;; - special properties in properties drawers,
 ;; - obsolete syntax for properties drawers,
 ;; - invalid duration in EFFORT property,
+;; - invalid ID property with a double colon,
 ;; - missing definition for footnote references,
 ;; - missing reference for footnote definitions,
 ;; - non-footnote definitions in footnote section,
@@ -686,6 +687,16 @@ Use :header-args: instead"
 	       (list (org-element-begin p)
 		     (format "Invalid effort duration format: %S" value))))))))
 
+(defun org-lint-invalid-id-property (ast)
+  (org-element-map ast 'node-property
+    (lambda (p)
+      (when (equal "ID" (org-element-property :key p))
+	(let ((value (org-element-property :value p)))
+	  (and (org-string-nw-p value)
+               (string-match-p "::" value)
+	       (list (org-element-begin p)
+		     (format "IDs should not include \"::\": %S" value))))))))
+
 (defun org-lint-link-to-local-file (ast)
   (org-element-map ast 'link
     (lambda (l)
@@ -1507,6 +1518,19 @@ AST is the buffer parse tree."
          ((memq (org-element-property :type deadline) '(inactive inactive-range))
           (list (org-element-begin planning) "Inactive timestamp in DEADLINE will not appear in agenda."))
          (t nil))))))
+
+(defvar org-beamer-frame-environment) ; defined in ox-beamer.el
+(defun org-lint-beamer-frame (ast)
+  "Check for occurrences of begin or end frame."
+  (require 'ox-beamer)
+  (org-with-point-at ast
+    (goto-char (point-min))
+    (let (result)
+      (while (re-search-forward
+              (concat "\\\\\\(begin\\|end\\){" org-beamer-frame-environment "}") nil t)
+        (push (list (match-beginning 0) "Beamer frame name may cause error when exporting.  Consider customizing `org-beamer-frame-environment'.") result))
+      result)))
+
 
 ;;; Checkers declaration
 
@@ -1684,6 +1708,11 @@ AST is the buffer parse tree."
   #'org-lint-invalid-effort-property
   :categories '(properties))
 
+(org-lint-add-checker 'invalid-id-property
+  "Report search string delimiter \"::\" in ID property"
+  #'org-lint-invalid-id-property
+  :categories '(properties))
+
 (org-lint-add-checker 'undefined-footnote-reference
   "Report missing definition for footnote references"
   #'org-lint-undefined-footnote-reference
@@ -1787,6 +1816,10 @@ AST is the buffer parse tree."
   "Report $ that might be treated as LaTeX fragment boundary."
   #'org-lint-LaTeX-$-ambiguous
   :categories '(markup) :trust 'low)
+(org-lint-add-checker 'beamer-frame
+  "Report that frame text contains beamer frame environment."
+  #'org-lint-beamer-frame
+  :categories '(export) :trust 'low)
 (org-lint-add-checker 'timestamp-syntax
   "Report malformed timestamps."
   #'org-lint-timestamp-syntax

lisp/org-macs.el

@@ -1263,7 +1263,7 @@ Otherwise, return nil."
   "Splits STRING into substrings at SEPARATORS.
 
 SEPARATORS is a regular expression.  When nil, it defaults to
-\"[ \f\t\n\r\v]+\".
+\"[ \\f\\t\\n\\r\\v]+\".
 
 Unlike `split-string', matching SEPARATORS at the beginning and
 end of string are ignored."

lisp/org-mobile.el

@@ -470,7 +470,7 @@ agenda view showing the flagged items."
       (insert "#+TAGS: " (mapconcat 'identity tags " ") "\n")
       (insert "#+ALLPRIORITIES: " org-mobile-allpriorities "\n")
       (when (file-exists-p (expand-file-name
-			    org-mobile-directory "agendas.org"))
+			    "agendas.org" org-mobile-directory))
 	(insert "* [[file:agendas.org][Agenda Views]]\n"))
       (pcase-dolist (`(,_ . ,link-name) files-alist)
 	(insert (format "* [[file:%s][%s]]\n" link-name link-name)))

lisp/org-persist.el

@@ -389,7 +389,7 @@ The keys are conses of (container . associated).")
 (defvar org-persist--index-age nil
   "The modification time of the index file, when it was loaded.")
 
-(defvar org-persist--report-time 0.5
+(defvar org-persist--report-time nil
   "Whether to report read/write time.
 
 When the value is a number, it is a threshold number of seconds.  If

lisp/org-table.el

@@ -5494,25 +5494,38 @@ for a horizontal separator line, or a list of field values as strings.
 The table is taken from the parameter TXT, or from the buffer at point."
   (if txt
       (with-temp-buffer
+	(buffer-disable-undo)
         (insert txt)
         (goto-char (point-min))
         (org-table-to-lisp))
     (save-excursion
       (goto-char (org-table-begin))
-      (let ((table nil))
-        (while (re-search-forward "\\=[ \t]*|" nil t)
-	  (let ((row nil))
-	    (if (looking-at "-")
-		(push 'hline table)
-	      (while (not (progn (skip-chars-forward " \t") (eolp)))
-		(push (buffer-substring
-		       (point)
-		       (progn (re-search-forward "[ \t]*\\(|\\|$\\)")
-			      (match-beginning 0)))
-		      row))
-	      (push (nreverse row) table)))
+      (let (table)
+        (while (progn (skip-chars-forward " \t")
+                      (eq (following-char) ?|))
+	  (forward-char)
+	  (push
+	   (if (eq (following-char) ?-)
+	       'hline
+	     (let (row)
+	       (while (progn
+                        (skip-chars-forward " \t")
+                        (not (eolp)))
+                 (let ((q (point)))
+                   (skip-chars-forward "^|\n")
+                   (goto-char
+                    (prog1
+                        (let ((p (point)))
+                          (unless (eolp) (setq p (1+ p)))
+                          p)
+	              (skip-chars-backward " \t" q)
+                      ;; Preserve text properties.  They are used when
+                      ;; calculating cell width.
+	              (push (buffer-substring q (point)) row)))))
+	       (nreverse row)))
+	   table)
 	  (forward-line))
-        (nreverse table)))))
+	(nreverse table)))))
 
 (defun org-table-collapse-header (table &optional separator max-header-lines)
   "Collapse the lines before `hline' into a single header.

lisp/org.el

@@ -101,10 +101,6 @@
 (require 'org-fold)
 
 (require 'org-cycle)
-(defvaralias 'org-hide-block-startup 'org-cycle-hide-block-startup)
-(defvaralias 'org-hide-drawer-startup 'org-cycle-hide-drawer-startup)
-(defvaralias 'org-pre-cycle-hook 'org-cycle-pre-hook)
-(defvaralias 'org-tab-first-hook 'org-cycle-tab-first-hook)
 (defalias 'org-global-cycle #'org-cycle-global)
 (defalias 'org-overview #'org-cycle-overview)
 (defalias 'org-content #'org-cycle-content)
@@ -5285,7 +5281,16 @@ for the start and end of inline results, respectively."
 	    (org-remove-flyspell-overlays-in nl-before-endline end-of-endline)
             (cond
 	     ((and org-src-fontify-natively
-                   (string= block-type "src"))
+                   ;; Technically, according to
+                   ;; `org-src-fontify-natively' docstring, we should
+                   ;; only fontify src blocks.  However, it is common
+                   ;; to use undocumented fontification of example
+                   ;; blocks with undocumented language specifier.
+                   ;; Keep this undocumented feature for user
+                   ;; convenience.
+                   t
+                   ;; (string= block-type "src")
+                   )
 	      (save-match-data
                 (org-src-font-lock-fontify-block (or lang "") block-start block-end))
 	      (add-text-properties bol-after-beginline block-end '(src-block t)))
@@ -5460,7 +5465,9 @@ for the start and end of inline results, respectively."
       ;; `org-target-link-regexp' matches one character before the
       ;; actual target.
       (unless (bolp) (forward-char -1))
-      (when (re-search-forward org-target-link-regexp limit t)
+      (when (if org-target-link-regexps
+                (org--re-list-search-forward org-target-link-regexps limit t)
+              (re-search-forward org-target-link-regexp limit t))
 	(org-remove-flyspell-overlays-in (match-beginning 1) (match-end 1))
 	(add-text-properties (match-beginning 1) (match-end 1)
 			     (list 'mouse-face 'highlight
@@ -5570,6 +5577,25 @@ highlighting was done, nil otherwise."
     (org-rear-nonsticky-at (match-end 1))
     t))
 
+(defun org-activate-folds (limit)
+  "Arrange trailing newlines after folds to inherit face before the fold."
+  (let ((next-unfolded-newline (search-forward "\n" limit 'move)))
+    (while (and next-unfolded-newline (org-fold-folded-p) (not (eobp)))
+      (setq next-unfolded-newline (search-forward "\n" limit 'move)))
+    (when next-unfolded-newline
+      (org-with-wide-buffer
+       (when (and (> (match-beginning 0) (point-min))
+                  (org-fold-folded-p (1- (match-beginning 0)))
+                  (not (org-fold-folded-p (1- (match-beginning 0)) 'org-link)))
+         (put-text-property
+          (match-beginning 0) (match-end 0)
+          'face
+          (get-text-property
+           (org-fold-previous-visibility-change
+            (1- (match-beginning 0)))
+           'face)))
+       t))))
+
 (defun org-outline-level ()
   "Compute the outline level of the heading at point.
 
@@ -5755,7 +5781,8 @@ needs to be inserted at a specific position in the font-lock sequence.")
           (progn
             (unless (null org-cite-activate-processor)
               (org-cite-try-load-processor org-cite-activate-processor))
-            '(org-cite-activate)))))
+            '(org-cite-activate))
+          '(org-activate-folds))))
     (setq org-font-lock-extra-keywords (delq nil org-font-lock-extra-keywords))
     (run-hooks 'org-font-lock-set-keywords-hook)
     ;; Now set the full font-lock-keywords
@@ -6182,7 +6209,7 @@ headline instead of current one."
     (`(heading . ,value) value)
     (_ nil)))
 
-(defun org-insert-heading (&optional arg invisible-ok top)
+(defun org-insert-heading (&optional arg invisible-ok level)
   "Insert a new heading or an item with the same depth at point.
 
 If point is at the beginning of a heading, insert a new heading
@@ -6211,12 +6238,19 @@ When INVISIBLE-OK is set, stop at invisible headlines when going
 back.  This is important for non-interactive uses of the
 command.
 
-When optional argument TOP is non-nil, insert a level 1 heading,
-unconditionally."
+When optional argument LEVEL is a number, insert a heading at
+that level.  For backwards compatibility, when LEVEL is non-nil
+but not a number, insert a level-1 heading."
   (interactive "P")
   (let* ((blank? (org--blank-before-heading-p (equal arg '(16))))
-	 (level (org-current-level))
-	 (stars (make-string (if (and level (not top)) level 1) ?*)))
+         (current-level (org-current-level))
+         (num-stars (or
+                     ;; Backwards compat: if LEVEL non-nil, level is 1
+                     (and level (if (wholenump level) level 1))
+                     current-level
+                     ;; This `1' is for when before first headline
+                     1))
+         (stars (make-string num-stars ?*)))
     (cond
      ((or org-insert-heading-respect-content
 	  (member arg '((4) (16)))
@@ -6225,7 +6259,7 @@ unconditionally."
       ;; Position point at the location of insertion.  Make sure we
       ;; end up on a visible headline if INVISIBLE-OK is nil.
       (org-with-limited-levels
-       (if (not level) (outline-next-heading) ;before first headline
+       (if (not current-level) (outline-next-heading) ;before first headline
 	 (org-back-to-heading invisible-ok)
 	 (when (equal arg '(16)) (org-up-heading-safe))
 	 (org-end-of-subtree invisible-ok 'to-heading)))
@@ -6238,7 +6272,7 @@ unconditionally."
                           (org-before-first-heading-p)))
         (insert "\n")
         (backward-char))
-      (when (and (not level) (not (eobp)) (not (bobp)))
+      (when (and (not current-level) (not (eobp)) (not (bobp)))
         (when (org-at-heading-p) (insert "\n"))
         (backward-char))
       (unless (and blank? (org-previous-line-empty-p))
@@ -8253,7 +8287,7 @@ If the file does not exist, throw an error."
 		      ;; Save position before error-ing out so user
 		      ;; can easily move back to the original buffer.
 		      (error (funcall save-position-maybe)
-			     (error (nth 1 err)))))))
+			     (error "%s" (error-message-string err)))))))
      ((functionp cmd)
       (save-match-data
 	(set-match-data link-match-data)
@@ -13864,6 +13898,9 @@ user."
 	  (setq txt (concat txt " (=>F)")))
 	(setq org-read-date-overlay
               (make-overlay (1- (line-end-position)) (line-end-position)))
+        ;; Avoid priority race with overlay used by calendar.el.
+        ;; See bug#69271.
+        (overlay-put org-read-date-overlay 'priority 1)
 	(org-overlay-display org-read-date-overlay txt 'secondary-selection)))))
 
 (defun org-read-date-analyze (ans def defdecode)
@@ -19863,9 +19900,14 @@ any extension which is used as the filename."
 It is saved as per `org-yank-image-save-method'.  The name for the
 image is prompted and the extension is automatically added to the
 end."
-  (let* ((ext (symbol-name (mailcap-mime-type-to-extension mimetype)))
+  (cl-assert (fboundp 'mailcap-mime-type-to-extension)) ; Emacs >=29
+  (cl-assert (fboundp 'file-name-with-extension)) ; Emacs >=28
+  (let* ((ext (symbol-name
+               (with-no-warnings ; Suppress warning in Emacs <29
+                 (mailcap-mime-type-to-extension mimetype))))
          (iname (funcall org-yank-image-file-name-function))
-         (filename (file-name-with-extension iname ext))
+         (filename (with-no-warnings ; Suppress warning in Emacs <28
+                     (file-name-with-extension iname ext)))
          (absname (expand-file-name
                    filename
                    (if (eq org-yank-image-save-method 'attach)
@@ -19936,7 +19978,10 @@ When nil, use `org-attach-method'."
 (defvar org-attach-method)
 
 (defun org--dnd-rmc (prompt choices)
-  (if (null (use-dialog-box-p))
+  (if (null (and
+             ;; Emacs <=28 does not have `use-dialog-box-p'.
+             (fboundp 'use-dialog-box-p)
+             (use-dialog-box-p)))
       (caddr (read-multiple-choice prompt choices))
     (setq choices
           (mapcar
@@ -20522,14 +20567,15 @@ With argument, move up ARG levels."
 
 (defun org-up-heading-safe ()
   "Move to the heading line of which the present line is a subheading.
-Return the heading level, as number or nil when there is no such heading.
+Return the true heading level, as number or nil when there is no such
+heading.
 
 When point is not at heading, go to the parent of the current heading.
 When point is at or inside an inlinetask, go to the containing
 heading.
 
-This version will not throw an error.  It will return the level of the
-headline found, or nil if no higher level is found.
+This version will not throw an error.  It will return the true level
+of the headline found, or nil if no higher level is found.
 
 When no higher level is found, the still move point to the containing
 heading, if there is any in the accessible portion of the buffer.
@@ -20545,7 +20591,7 @@ available portion of the buffer."
              (<= (point-min) (org-element-begin parent)))
         (progn
           (goto-char (org-element-begin parent))
-          (org-element-property :level parent))
+          (org-element-property :true-level parent))
       (when (and current-heading
                  (<= (point-min) (org-element-begin current-heading)))
         (goto-char (org-element-begin current-heading))

lisp/ox-beamer.el

@@ -148,6 +148,22 @@ which is replaced with the subtitle."
   :package-version '(Org . "8.3")
   :type '(string :tag "Format string"))
 
+(defcustom org-beamer-frame-environment "orgframe"
+  "Name of the alternative beamer frame environment.
+In frames marked as fragile, this environment is used in place of
+the usual frame environment.
+
+This permits insertion of a beamer frame inside example blocks,
+working around beamer limitations.  See
+https://list.orgmode.org/87a5nux3zr.fsf@t14.reltub.ca/T/#mc7221e93f138bdd56c916b194b9230d3a6c3de09
+
+This option may need to be changed when \"\\end{orgframe}\" string is
+used inside beamer slides."
+  :group 'org-export-beamer
+  :package-version '(Org . "9.7")
+  :type '(string :tag "Beamer frame")
+  :safe (lambda (str) (string-match-p "^[A-Za-z]+$" str)))
+
 
 ;;; Internal Variables
 
@@ -408,12 +424,14 @@ used as a communication channel."
   "Format HEADLINE as a frame.
 CONTENTS holds the contents of the headline.  INFO is a plist
 used as a communication channel."
-  (let ((fragilep
-	 ;; FRAGILEP is non-nil when HEADLINE contains an element
-	 ;; among `org-beamer-verbatim-elements'.
-	 (org-element-map headline org-beamer-verbatim-elements 'identity
-			  info 'first-match)))
-    (concat "\\begin{frame}"
+  (let* ((fragilep
+	  ;; FRAGILEP is non-nil when HEADLINE contains an element
+	  ;; among `org-beamer-verbatim-elements'.
+	  (org-element-map headline org-beamer-verbatim-elements 'identity
+			   info 'first-match))
+         (frame (or (and fragilep org-beamer-frame-environment)
+                    "frame")))
+    (concat "\\begin{" frame "}"
 	    ;; Overlay specification, if any. When surrounded by
 	    ;; square brackets, consider it as a default
 	    ;; specification.
@@ -480,7 +498,7 @@ used as a communication channel."
 	    ;; output.
 	    (if (not fragilep) contents
 	      (replace-regexp-in-string "\\`\n*" "\\& " (or contents "")))
-	    "\\end{frame}")))
+	    "\\end{" frame "}")))
 
 (defun org-beamer--format-block (headline contents info)
   "Format HEADLINE as a block.
@@ -814,7 +832,6 @@ contextual information."
 	  (org-export-get-reference radio-target info)
 	  text))
 
-
 ;;;; Template
 ;;
 ;; Template used is similar to the one used in `latex' backend,
@@ -832,6 +849,10 @@ holding export options."
 	  (format-time-string "%% Created %Y-%m-%d %a %H:%M\n"))
      ;; Document class, packages, and some configuration.
      (org-latex-make-preamble info)
+     ;; Define the alternative frame environment.
+     (unless (equal "frame" org-beamer-frame-environment)
+       (format "\\newenvironment<>{%s}[1][]{\\begin{frame}#2[environment=%1$s,#1]}{\\end{frame}}\n"
+               org-beamer-frame-environment))
      ;; Insert themes.
      (let ((format-theme
 	    (lambda (prop command)

lisp/ox-latex.el

@@ -1768,7 +1768,7 @@ explicitly been loaded.  Then it is added to the rest of
 package's options.
 
 The optional argument to Babel or the mandatory argument to
-`\babelprovide' command may be \"AUTO\" which is then replaced
+`\\babelprovide' command may be \"AUTO\" which is then replaced
 with the language of the document or
 `org-export-default-language' unless language in question is
 already loaded.
@@ -2733,7 +2733,7 @@ contextual information."
   (let ((code (org-element-property :value inline-src-block))
         (lang (org-element-property :language inline-src-block)))
     (pcase (plist-get info :latex-src-block-backend)
-      (`verbatim (org-latex--text-markup code 'code info))
+      ((or `verbatim (guard (not lang))) (org-latex--text-markup code 'code info))
       (`minted (org-latex-inline-src-block--minted info code lang))
       (`engraved (org-latex-inline-src-block--engraved info code lang))
       (`listings (org-latex-inline-src-block--listings info code lang))
@@ -2761,9 +2761,10 @@ INFO, CODE, and LANG are provided by `org-latex-inline-src-block'."
   "Transcode an inline src block's content from Org to LaTeX, using engrave-faces.
 INFO, CODE, and LANG are provided by `org-latex-inline-src-block'."
   (let ((engraved-theme (plist-get info :latex-engraved-theme)))
+    (when (stringp engraved-theme)
+      (setq engraved-theme (intern engraved-theme)))
     (org-latex-src--engrave-code
-     code lang
-     (and engraved-theme (intern engraved-theme)) nil
+     code lang engraved-theme nil
      (plist-get info :latex-engraved-options) t)))
 
 (defun org-latex-inline-src-block--listings (info code lang)
@@ -3897,9 +3898,16 @@ and FLOAT are extracted from SRC-BLOCK and INFO in `org-latex-src-block'."
                `(("linenos")
                  ("firstnumber" ,(number-to-string (1+ num-start)))))
              (and local-options `((,local-options))))))
-         (engraved-doc-theme (plist-get info :latex-engraved-theme))
-         (engraved-theme (or (plist-get attributes :engraved-theme)
-                             engraved-doc-theme))
+         (intern-safe
+          (lambda (name)
+            (if (stringp name)
+                (intern name)
+              name)))
+         (engraved-doc-theme
+          (funcall intern-safe (plist-get info :latex-engraved-theme)))
+         (engraved-theme
+          (or (funcall intern-safe (plist-get attributes :engraved-theme))
+              engraved-doc-theme))
          (content
           (let* ((code-info (org-export-unravel-code src-block))
                  (max-width
@@ -3925,7 +3933,7 @@ and FLOAT are extracted from SRC-BLOCK and INFO in `org-latex-src-block'."
                  (org-latex-src--engrave-mathescape-p info options)))
             (org-latex-src--engrave-code
              content lang
-             (and engraved-theme (intern engraved-theme))
+             engraved-theme
              (not (eq engraved-theme engraved-doc-theme))
              options))))
     (concat (car float-env) body (cdr float-env))))

lisp/ox-man.el

@@ -510,8 +510,9 @@ contextual information."
                         (expand-file-name "reshilite" tmpdir)))
              (org-lang (org-element-property :language inline-src-block))
              (lst-lang
-	      (cadr (assq (intern org-lang)
-			  (plist-get info :man-source-highlight-langs))))
+              (and org-lang
+	           (cadr (assq (intern org-lang)
+			       (plist-get info :man-source-highlight-langs)))))
 
              (cmd (concat (expand-file-name "source-highlight")
                           " -s " lst-lang
@@ -757,8 +758,9 @@ contextual information."
 	   (code (org-element-property :value src-block))
 	   (org-lang (org-element-property :language src-block))
 	   (lst-lang
-	    (cadr (assq (intern org-lang)
-			(plist-get info :man-source-highlight-langs))))
+            (and org-lang
+	         (cadr (assq (intern org-lang)
+			     (plist-get info :man-source-highlight-langs)))))
 	   (cmd (concat "source-highlight"
 			" -s " lst-lang
 			" -f groff_man "

lisp/ox-odt.el

@@ -3112,7 +3112,7 @@ and prefix with \"OrgSrc\".  For example,
 (defun org-odt-do-format-code
     (code info &optional lang refs retain-labels num-start)
   (let* ((lang (or (assoc-default lang org-src-lang-modes) lang))
-	 (lang-mode (and lang (intern (format "%s-mode" lang))))
+	 (lang-mode (if lang (intern (format "%s-mode" lang)) #'ignore))
 	 (code-lines (org-split-string code "\n"))
 	 (code-length (length code-lines))
 	 (use-htmlfontify-p (and (functionp lang-mode)

lisp/ox-texinfo.el

@@ -1681,8 +1681,9 @@ as a communication channel."
   "Transcode a SRC-BLOCK element from Org to Texinfo.
 CONTENTS holds the contents of the item.  INFO is a plist holding
 contextual information."
-  (let* ((lisp (string-match-p "lisp"
-			       (org-element-property :language src-block)))
+  (let* ((lisp (string-match-p
+                "lisp"
+		(or (org-element-property :language src-block) "")))
 	 (code (org-texinfo--sanitize-content
 		(org-export-format-code-default src-block info)))
 	 (value (format

testing/examples/Basic.bib

@@ -7,3 +7,14 @@
   doi = {10.1007/978-3-642-23816-1},
   isbn = {9783642238161}
 }
+
+@InCollection{Geyer2011,
+  author          = {Geyer, Charles J},
+  title           = {{Introduction to Markov\plus Chain Monte Carlo}},
+  year            = 2011,
+  booktitle       = {{Handbook of Markov Chain Monte Carlo}},
+  editor          = {Brooks, Steve and Gelman, Andrew and Jones, Galin and Meng,
+		  Xiao-Li},
+  publisher       = {CRC press},
+  pages           = 45,
+}

testing/lisp/test-ob.el

@@ -2545,6 +2545,225 @@ abc
 		(lambda (&rest _) (error "No warnings should occur"))))
        (org-babel-import-elisp-from-file (buffer-file-name))))))
 
+(ert-deftest test-ob/demarcate-block-split-duplication ()
+  "Test duplication of language, body, switches, and headers in splitting."
+  (let ((caption "#+caption: caption.")
+        (regexp (rx "#+caption: caption."))
+        (org-adapt-indentation nil))
+    (org-test-with-temp-text (format "
+%s
+#+header: :var edge=\"also duplicated\"
+#+header: :wrap \"src any-spanish -n\"
+#+name: Nobody
+#+begin_src any-english -i -n :var here=\"duplicated\" :wrap \"src any-english -n\"
+
+above split
+<point>
+below split
+
+#+end_src
+do not org-indent-block text here
+" caption)
+      (let ((wrap-val "src any-spanish -n") above below avars bvars)
+        (org-babel-demarcate-block)
+        (goto-char (point-min))
+        (org-babel-next-src-block) ;; upper source block
+        (setq above (org-babel-get-src-block-info))
+        (setq avars (org-babel--get-vars (nth 2 above)))
+        (org-babel-next-src-block) ;; lower source block
+        (setq below (org-babel-get-src-block-info))
+        (setq bvars (org-babel--get-vars (nth 2 below)))
+        ;; duplicated multi-line header arguments:
+        (should (string= "also duplicated" (cdr (assq 'edge avars))))
+        (should (string= "also duplicated" (cdr (assq 'edge bvars))))
+        (should (string= wrap-val (cdr (assq :wrap (nth 2 above)))))
+        (should (string= wrap-val (cdr (assq :wrap (nth 2 below)))))
+        ;; duplicated language, other header arguments, and switches:
+        (should (string= "any-english" (nth 0 above)))
+        (should (string= "any-english" (nth 0 below)))
+        (should (string= "above split" (org-trim (nth 1 above))))
+        (should (string= "below split" (org-trim (nth 1 below))))
+        (should (string= "duplicated" (cdr (assq 'here avars))))
+        (should (string= "duplicated" (cdr (assq 'here bvars))))
+        (should (string= "-i -n" (nth 3 above)))
+        (should (string= "-i -n" (nth 3 below)))
+        ;; non-duplication of name and caption, which is not in above/below.
+        (should (string= "Nobody" (nth 4 above)))
+        (should-not (string= "" (nth 4 below)))
+        (goto-char (point-min))
+        (should (re-search-forward regexp))
+        (should-not (re-search-forward regexp nil 'noerror))))))
+
+(ert-deftest test-ob/demarcate-block-split-prefix-point ()
+  "Test prefix argument point splitting."
+  (let ((org-adapt-indentation t)
+        (org-edit-src-content-indentation 2)
+        (org-src-preserve-indentation nil)
+        (ok-col 11)
+        (stars "^\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*"))
+    (org-test-with-temp-text "
+********** 10 stars with point between two lines
+           #+begin_src emacs-lisp
+             ;; to upper block
+             <point>
+             ;; to lower block
+           #+end_src
+"
+      (org-babel-demarcate-block 'a-prefix-arg)
+      (goto-char (point-min))
+      (dolist (regexp `(,stars
+                        "#\\+beg" ";; to upper block" "#\\+end"
+                        ,stars
+                        "#\\+beg" ";; to lower block" "#\\+end"))
+        (should (re-search-forward regexp))
+        (goto-char (match-beginning 0))
+        (cond ((string= regexp stars)
+               (should (= 0 (current-column))))
+              ((string-prefix-p ";;" regexp)
+               (should (= (+ ok-col org-edit-src-content-indentation)
+                          (current-column))))
+              (t (should (= ok-col (current-column)))))))))
+
+(ert-deftest test-ob/demarcate-block-split-prefix-region ()
+  "Test prefix argument region splitting."
+  (let ((org-adapt-indentation t)
+        (org-edit-src-content-indentation 2)
+        (org-src-preserve-indentation nil)
+        (ok-col 11)
+        (stars "^\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*")
+        (parts '("to upper block" "mark those words as region" "to lower block")))
+    (org-test-with-temp-text (format "
+********** 10 stars with region between two lines
+           #+header: :var b=\"also seen\"
+           #+begin_src any-language -i -n :var a=\"seen\"
+             %s
+             <point>%s
+             %s
+           #+end_src
+" (nth 0 parts) (nth 1 parts) (nth 2 parts))
+      (let ((n 0) info vars)
+        (transient-mark-mode 1)
+        (push-mark (point) t t)
+        (search-forward (nth 1 parts))
+        (org-babel-demarcate-block 'a-prefix-argument)
+        (goto-char (point-min))
+        (while (< n (length parts))
+          (org-babel-next-src-block)
+          (setq info (org-babel-get-src-block-info))
+          (setq vars (org-babel--get-vars (nth 2 info)))
+          (should (string= "any-language" (nth 0 info)))
+          (should (string= (nth n parts) (org-trim (nth 1 info))))
+          (should (string= "seen" (cdr (assq 'a vars))))
+          (should (string= "also seen" (cdr (assq 'b vars))))
+          (should (string= "-i -n" (nth 3 info)))
+          (cl-incf n)))
+      (goto-char (point-min))
+      (dolist (regexp `(,stars
+                        "#\\+beg" ,(nth 0 parts) "#\\+end"
+                        ,stars
+                        "#\\+beg" ,(nth 1 parts) "#\\+end"
+                        ,stars
+                        "#\\+beg" ,(nth 2 parts) "#\\+end"))
+        (should (re-search-forward regexp))
+        (goto-char (match-beginning 0))
+        (cond ((string= regexp stars)
+               (should (= 0 (current-column))))
+              ((memq regexp parts)
+               (should (= (+ ok-col org-edit-src-content-indentation)
+                          (current-column))))
+              (t (should (= ok-col (current-column)))))))))
+
+(ert-deftest test-ob/demarcate-block-split-user-errors ()
+  "Test for `user-error's in splitting"
+  (let ((org-adapt-indentation t)
+        (org-edit-src-content-indentation 2)
+        (org-src-preserve-indentation))
+    (let* ((caption "#+caption: caption.")
+           (within-body ";; within-body")
+           (below-block "# below block")
+           (template  "
+%s%s
+#+begin_src emacs-lisp
+
+  %s
+
+#+end_src
+
+%s%s
+"))
+      ;; Test point at caption.
+      (org-test-with-temp-text
+          (format template "<point>" caption within-body below-block "")
+        (should-error (org-babel-demarcate-block) :type 'user-error))
+      ;; Test region from below the block (mark) to within the body (point).
+      (org-test-with-temp-text
+          (format template "" caption within-body below-block "<point>")
+        ;; Set mark.
+        (transient-mark-mode 1)
+        (push-mark (point) t t)
+        ;; Set point.
+        (should (search-backward within-body nil 'noerror))
+        (goto-char (match-beginning 0))
+        (should-error (org-babel-demarcate-block) :type 'user-error)))))
+
+(ert-deftest test-ob/demarcate-block-wrap-point ()
+  "Test wrapping point in blank lines below a source block."
+  (org-test-with-temp-text "
+#+begin_src any-language -i -n :var here=\"not duplicated\"
+to upper block
+#+end_src
+<point>
+"
+    (let (info vars)
+      (org-babel-demarcate-block)
+      (goto-char (point-min))
+      (org-babel-next-src-block)
+      (setq info (org-babel-get-src-block-info))  ;; upper source block info
+      (setq vars (org-babel--get-vars (nth 2 info)))
+      (should (string= "any-language" (nth 0 info)))
+      (should (string= "to upper block" (org-trim (nth 1 info))))
+      (should (string= "not duplicated" (cdr (assq 'here vars))))
+      (should (string= "-i -n" (nth 3 info)))
+      (org-babel-next-src-block)
+      (setq info (org-babel-get-src-block-info)) ;; lower source block info
+      (setq vars (org-babel--get-vars (nth 2 info)))
+      (should (string= "any-language" (nth 0 info)))
+      (should (string= "" (org-trim (nth 1 info))))
+      (should-not vars)
+      (should (string= "" (nth 3 info))))))
+
+(ert-deftest test-ob/demarcate-block-wrap-region ()
+  "Test wrapping region in blank lines below a source block."
+  (let ((region-text "mark this line as region leaving point in blank lines"))
+    (org-test-with-temp-text (format "
+#+begin_src any-language -i -n :var here=\"not duplicated\"
+to upper block
+#+end_src
+<point>
+%s
+" region-text)
+      (let (info vars)
+        (transient-mark-mode 1)
+        (push-mark (point) t t)
+        (search-forward region-text)
+        (exchange-point-and-mark)
+        (org-babel-demarcate-block)
+        (goto-char (point-min))
+        (org-babel-next-src-block)
+        (setq info (org-babel-get-src-block-info))  ;; upper source block info
+        (setq vars (org-babel--get-vars (nth 2 info)))
+        (should (string= "any-language" (nth 0 info)))
+        (should (string= "to upper block" (org-trim (nth 1 info))))
+        (should (string= "not duplicated" (cdr (assq 'here vars))))
+        (should (string= "-i -n" (nth 3 info)))
+        (org-babel-next-src-block)
+        (setq info (org-babel-get-src-block-info)) ;; lower source block info
+        (setq vars (org-babel--get-vars (nth 2 info)))
+        (should (string= "any-language" (nth 0 info)))
+        (should (string= region-text (org-trim (nth 1 info))))
+        (should-not vars)
+        (should (string= "" (nth 3 info)))))))
+
 (provide 'test-ob)
 
 ;;; test-ob ends here

testing/lisp/test-oc-basic.el

@@ -156,5 +156,24 @@ Text: [cite/t: Citing ; @friends; and @friends also; is duplication.]"
            (search-forward "Text: Citing van Dongen, M.R.C. (2012), and van Dongen, M.R.C. (2012)
 also is duplication." nil t)))))))
 
+(ert-deftest test-org-cite-basic/export-bibliography ()
+  "Test `org-cite-basic-export-bibliography'."
+  ;; Drop {...} Bibtex brackets and render entities.
+  (org-test-with-temp-text
+      (format
+       "#+bibliography: %s
+#+cite_export: basic
+Foo [cite/plain:@Geyer2011]
+#+print_bibliography:"
+       (expand-file-name "examples/Basic.bib" org-test-dir))
+    (let ((export-buffer "*Test ASCII Export*")
+          (org-export-show-temporary-export-buffer nil))
+      (org-export-to-buffer 'ascii export-buffer)
+      (with-current-buffer export-buffer
+        (let ((case-fold-search t))
+          (should
+           ;; Rendered from {Introduction to Markov\plus Chain Monte Carlo}
+           (search-forward "Introduction to Markov+ Chain Monte Carlo" nil t)))))))
+
 (provide 'test-oc-basic)
 ;;; test-oc-basic.el ends here

testing/lisp/test-ol.el

@@ -381,6 +381,128 @@ See https://github.com/yantar92/org/issues/4."
 	 (equal (format "[[file:%s::*foo bar][foo bar]]" file file)
 		(org-store-link nil)))))))
 
+(ert-deftest test-org-link/precise-link-target ()
+  "Test `org-link-precise-link-target` specifications."
+  (org-test-with-temp-text "* H1<point>\n* H2\n"
+    (should
+     (equal '("*H1" "H1" 1)
+            (org-link-precise-link-target))))
+  (org-test-with-temp-text "* H1\n#+name: foo<point>\n#+begin_example\nhi\n#+end_example\n"
+    (should
+     (equal '("foo" "foo" 6)
+            (org-link-precise-link-target))))
+  (org-test-with-temp-text "\nText<point>\n* H1\n"
+    (should
+     (equal '("Text" nil 2)
+            (org-link-precise-link-target))))
+  (org-test-with-temp-text "\n<point>\n* H1\n"
+    (should
+     (equal nil (org-link-precise-link-target)))))
+
+(defmacro test-ol-stored-link-with-text (text &rest body)
+  "Return :link and :description from link stored in body."
+  (declare (indent 1))
+  `(let (org-store-link-plist)
+     (org-test-with-temp-text-in-file ,text
+       ,@body
+       (list (plist-get org-store-link-plist :link)
+             (plist-get org-store-link-plist :description)))))
+
+(ert-deftest test-org-link/id-store-link ()
+  "Test `org-id-store-link' specifications."
+  (let ((org-id-link-to-org-use-id nil))
+    (should
+     (equal '(nil nil)
+            (test-ol-stored-link-with-text "* H1\n:PROPERTIES:\n:ID: abc\n:END:\n"
+              (org-id-store-link-maybe t)))))
+  ;; On a headline, link to that headline's ID.  Use heading as the
+  ;; description of the link.
+  (let ((org-id-link-to-org-use-id t))
+    (should
+     (equal '("id:abc" "H1")
+            (test-ol-stored-link-with-text "* H1\n:PROPERTIES:\n:ID: abc\n:END:\n"
+              (org-id-store-link-maybe t)))))
+  ;; Remove TODO keywords etc from description of the link.
+  (let ((org-id-link-to-org-use-id t))
+    (should
+     (equal '("id:abc" "H1")
+            (test-ol-stored-link-with-text "* TODO [#A] H1 :tag:\n:PROPERTIES:\n:ID: abc\n:END:\n"
+              (org-id-store-link-maybe t)))))
+  ;; create-if-interactive
+  (let ((org-id-link-to-org-use-id 'create-if-interactive))
+    (should
+     (equal '("id:abc" "H1")
+            (cl-letf (((symbol-function 'org-id-new)
+                       (lambda (&rest _rest) "abc")))
+              (test-ol-stored-link-with-text "* H1\n"
+                (org-id-store-link-maybe t)))))
+    (should
+     (equal '(nil nil)
+            (test-ol-stored-link-with-text "* H1\n"
+              (org-id-store-link-maybe nil)))))
+  ;; create-if-interactive-and-no-custom-id
+  (let ((org-id-link-to-org-use-id 'create-if-interactive-and-no-custom-id))
+    (should
+     (equal '("id:abc" "H1")
+            (cl-letf (((symbol-function 'org-id-new)
+                       (lambda (&rest _rest) "abc")))
+              (test-ol-stored-link-with-text "* H1\n"
+                (org-id-store-link-maybe t)))))
+    (should
+     (equal '(nil nil)
+            (test-ol-stored-link-with-text "* H1\n:PROPERTIES:\n:CUSTOM_ID: xyz\n:END:\n"
+              (org-id-store-link-maybe t))))
+    (should
+     (equal '(nil nil)
+            (test-ol-stored-link-with-text "* H1\n"
+              (org-id-store-link-maybe nil)))))
+  ;; use-context should have no effect when on the headline with an id
+  (let ((org-id-link-to-org-use-id t)
+        (org-id-link-use-context t))
+    (should
+     (equal '("id:abc" "H2")
+            (test-ol-stored-link-with-text "* H1\n** H2<point>\n:PROPERTIES:\n:ID: abc\n:END:\n"
+              ;; simulate previously getting an inherited value
+              (move-marker org-entry-property-inherited-from 1)
+              (org-id-store-link-maybe t))))))
+
+(ert-deftest test-org-link/id-store-link-using-parent ()
+  "Test `org-id-store-link' specifications with `org-id-link-consider-parent-id` set."
+  ;; when using context to still find specific heading
+  (let ((org-id-link-to-org-use-id t)
+        (org-id-link-consider-parent-id t)
+        (org-id-link-use-context t))
+    (should
+     (equal '("id:abc::*H2" "H2")
+            (test-ol-stored-link-with-text "* H1\n:PROPERTIES:\n:ID: abc\n:END:\n** H2\n<point>"
+              (org-id-store-link))))
+    (should
+     (equal '("id:abc::name" "name")
+            (test-ol-stored-link-with-text "* H1\n:PROPERTIES:\n:ID: abc\n:END:\n\n#+name: name\n<point>#+begin_example\nhi\n#+end_example\n"
+              (org-id-store-link))))
+    (should
+     (equal '("id:abc" "H1")
+            (test-ol-stored-link-with-text "* H1<point>\n:PROPERTIES:\n:ID: abc\n:END:\n** H2\n"
+              (org-id-store-link))))
+    ;; should not use newly added ids as search string, e.g. in an empty file
+    (should
+     (let (name result)
+       (setq result
+             (cl-letf (((symbol-function 'org-id-new)
+                        (lambda (&rest _rest) "abc")))
+               (test-ol-stored-link-with-text "<point>"
+                 (setq name (buffer-name))
+                 (org-id-store-link))))
+       (equal `("id:abc" ,name) result))))
+  ;; should not find targets in the next section
+  (let ((org-id-link-to-org-use-id 'use-existing)
+        (org-id-link-consider-parent-id t)
+        (org-id-link-use-context t))
+    (should
+     (equal '(nil nil)
+            (test-ol-stored-link-with-text "* H1\n:PROPERTIES:\n:ID: abc\n:END:\n* H2\n** <point>Target\n"
+              (org-id-store-link-maybe t))))))
+
 
 ;;; Radio Targets
 

testing/lisp/test-org-agenda.el

@@ -687,6 +687,47 @@ Sunday      7 January 2024
     (should-not (org-agenda-files)))
   (org-test-agenda--kill-all-agendas))
 
+(ert-deftest test-org-agenda/skip-deadline-prewarning-if-scheduled ()
+  "Test `org-agenda-skip-deadline-prewarning-if-scheduled'."
+  (org-test-at-time
+   "2024-01-15"
+   (let ((org-agenda-skip-deadline-prewarning-if-scheduled t))
+     (org-test-agenda-with-agenda
+      "* TODO foo\nDEADLINE: <2024-01-20 Sat> SCHEDULED: <2024-01-19 Fri>"
+      (org-agenda-list nil nil 1)
+      (should-not (search-forward "In " nil t))))
+   (let ((org-agenda-skip-deadline-prewarning-if-scheduled 10))
+     (org-test-agenda-with-agenda
+      "* TODO foo\nDEADLINE: <2024-01-20 Sat> SCHEDULED: <2024-01-19 Fri>"
+      (org-agenda-list nil nil 1)
+      (should (search-forward "In " nil t))))
+   ;; Custom prewarning cookie "-3d", so there should be no warning anyway.
+   (let ((org-agenda-skip-deadline-prewarning-if-scheduled 10))
+     (org-test-agenda-with-agenda
+      "* TODO foo\nDEADLINE: <2024-01-20 Sat -3d> SCHEDULED: <2024-01-19 Fri>"
+      (org-agenda-list nil nil 1)
+      (should-not (search-forward "In " nil t))))
+   (let ((org-agenda-skip-deadline-prewarning-if-scheduled 3))
+     (org-test-agenda-with-agenda
+      "* TODO foo\nDEADLINE: <2024-01-20 Sat> SCHEDULED: <2024-01-19 Fri>"
+      (org-agenda-list nil nil 1)
+      (should-not (search-forward "In " nil t))))
+   (let ((org-agenda-skip-deadline-prewarning-if-scheduled nil))
+     (org-test-agenda-with-agenda
+      "* TODO foo\nDEADLINE: <2024-01-20 Sat> SCHEDULED: <2024-01-19 Fri>"
+      (org-agenda-list nil nil 1)
+      (should (search-forward "In " nil t))))
+   (let ((org-agenda-skip-deadline-prewarning-if-scheduled 'pre-scheduled))
+     (org-test-agenda-with-agenda
+      "* TODO foo\nDEADLINE: <2024-01-20 Sat> SCHEDULED: <2024-01-16 Tue>"
+      (org-agenda-list nil nil 1)
+      (should-not (search-forward "In " nil t))))
+   (let ((org-agenda-skip-deadline-prewarning-if-scheduled 'pre-scheduled))
+     (org-test-agenda-with-agenda
+      "* TODO foo\nDEADLINE: <2024-01-20 Sat> SCHEDULED: <2024-01-15 Mon>"
+      (org-agenda-list nil nil 1)
+      (should (search-forward "In " nil t))))))
+
 
 ;; agenda redo
 

testing/lisp/test-org-element.el

@@ -755,6 +755,15 @@ Some other text
 		   (text (org-element-map tree 'plain-text 'identity nil t)))
 	      (org-element-set text "b")
 	      (org-element-map tree 'plain-text 'identity nil t)))))
+  ;; Replace string inside anonymous element with another string.
+  (let* ((parent (org-element-create 'anonymous nil "test"))
+	 (str (car (org-element-contents parent))))
+    (let ((return (org-element-set str "repl"))
+          (new (car (org-element-contents parent))))
+      ;; Return the modified value.
+      (should (eq return new))
+      (should (equal new "repl"))
+      (should (eq (org-element-parent new) parent))))
   ;; KEEP-PROPS
   (should
    (org-element-property
@@ -2378,6 +2387,23 @@ e^{i\\pi}+1=0
       (org-element-property
        :type
        (org-element-map (org-element-parse-buffer) 'link #'identity nil t)))))
+  (should
+   (equal
+    "radio"
+    (org-test-with-temp-text "<<<radio>>><<<radio2>>><<<foo>>>A radio link"
+      (org-update-radio-target-regexp)
+      (org-element-property
+       :type
+       (org-element-map (org-element-parse-buffer) 'link #'identity nil t)))))
+  (should
+   (equal
+    "radio"
+    (let ((org-target-link-regexp-limit 9))
+      (org-test-with-temp-text "<<<radio>>><<<radio2>>><<<foo>>>A radio link"
+        (org-update-radio-target-regexp)
+        (org-element-property
+         :type
+         (org-element-map (org-element-parse-buffer) 'link #'identity nil t))))))
   ;; Pathological case: radio target of length 1 at beginning of line
   ;; not followed by spaces.
   (should

testing/lisp/test-org-table.el

@@ -1849,7 +1849,21 @@ See also `test-org-table/copy-field'."
   (should
    (org-test-with-temp-text "|-<point>--|---------|\n|---|---|-----|"
      (org-table-align)
-     t)))
+     t))
+  ;; Adjust table width.
+  (should
+   (equal
+    (let ((org-link-descriptive t))
+      (org-test-with-temp-text "
+| a        | b |
+|----------+---|
+| [[c][c]] | d |<point>"
+        (org-table-align)
+        (buffer-string)))
+    "
+| a | b |
+|---+---|
+| [[c][c]] | d |")))
 
 (ert-deftest test-org-table/align-buffer-tables ()
   "Align all tables when updating buffer."

testing/lisp/test-org.el

@@ -1980,8 +1980,30 @@ CLOCK: [2022-09-17 sam. 11:00]--[2022-09-17 sam. 11:46] =>  0:46"
 	    (let ((org-insert-heading-respect-content nil))
 	      (org-insert-heading '(16)))
 	    (buffer-string))))
-  ;; When optional TOP-LEVEL argument is non-nil, always insert
-  ;; a level 1 heading.
+  ;; When optional LEVEL argument is a number, insert a heading at
+  ;; that level.
+  (should
+   (equal "* H1\n** H2\n* "
+	  (org-test-with-temp-text "* H1\n** H2<point>"
+	    (org-insert-heading nil nil 1)
+	    (buffer-string))))
+  (should
+   (equal "* H1\n** H2\n** "
+	  (org-test-with-temp-text "* H1\n** H2<point>"
+	    (org-insert-heading nil nil 2)
+	    (buffer-string))))
+  (should
+   (equal "* H1\n** H2\n*** "
+	  (org-test-with-temp-text "* H1\n** H2<point>"
+	    (org-insert-heading nil nil 3)
+	    (buffer-string))))
+  (should
+   (equal "* H1\n- item\n* "
+	  (org-test-with-temp-text "* H1\n- item<point>"
+	    (org-insert-heading nil nil 1)
+	    (buffer-string))))
+  ;; When optional LEVEL argument is non-nil, always insert a level 1
+  ;; heading.
   (should
    (equal "* H1\n** H2\n* "
 	  (org-test-with-temp-text "* H1\n** H2<point>"
@@ -2436,6 +2458,13 @@ Test
 ** H2<point>"
     (should (= 1 (org-up-heading-safe)))
     (should (looking-at-p "^\\* H1")))
+  ;; Return true level.  Ignore `org-odd-levels-only'.
+  (let ((org-odd-levels-only t))
+    (org-test-with-temp-text "
+*** H1
+***** H2<point>"
+      (should (= 3 (org-up-heading-safe)))
+      (should (looking-at-p "^\\*\\{3\\} H1"))))
   ;; Do not jump beyond the level 1 heading.
   (org-test-with-temp-text "
 Text.