Update to Org 9.6-31-g954a95

14 files changed, 141 insertions, 88 deletions

diff --git a/doc/misc/org.org b/doc/misc/org.org
index 43d85099cff..0b926e3ceed 100644
--- a/doc/misc/org.org
+++ b/doc/misc/org.org
@@ -1401,7 +1401,7 @@ you, configure the option ~org-table-auto-blank-field~.
 - {{{kbd(M-x org-table-blank-field)}}} ::
 
   #+findex: org-table-blank-field
-  Blank the field at point.
+  Blank the current table field or active region.
 
 - {{{kbd(S-TAB)}}} (~org-table-previous-field~) ::
 
diff --git a/lisp/org/ob-comint.el b/lisp/org/ob-comint.el
index e8d83670767..064ba94464f 100644
--- a/lisp/org/ob-comint.el
+++ b/lisp/org/ob-comint.el
@@ -117,6 +117,14 @@ or user `keyboard-quit' during execution of body."
 	 (goto-char (process-mark (get-buffer-process (current-buffer))))
 	 (insert dangling-text)
 
+         ;; Replace partially supplied input lines.
+         ;; This is needed when output filter spits partial lines that
+         ;; do not include a full prompt at a time.
+         (setq string-buffer
+               (replace-regexp-in-string
+                comint-prompt-regexp
+                ,org-babel-comint-prompt-separator
+                string-buffer))
 	 ;; remove echo'd FULL-BODY from input
 	 (when (and ,remove-echo ,full-body
 		    (string-match
diff --git a/lisp/org/ob-core.el b/lisp/org/ob-core.el
index 5b78ee946ff..f69538f78c9 100644
--- a/lisp/org/ob-core.el
+++ b/lisp/org/ob-core.el
@@ -2709,7 +2709,9 @@ specified as an an \"attachment:\" style link."
                 ((and 'attachment (guard in-attach-dir)) "attachment")
                 (_ "file"))
               (if (and request-attachment in-attach-dir)
-                  (file-relative-name result-file-name)
+                  (file-relative-name
+                   result-file-name
+                   (file-name-as-directory attach-dir))
 	        (if (and default-directory
 		         base-file-name same-directory?)
 		    (if (eq org-link-file-path-type 'adaptive)
diff --git a/lisp/org/ol.el b/lisp/org/ol.el
index cd52e9cf4df..3ae8f887554 100644
--- a/lisp/org/ol.el
+++ b/lisp/org/ol.el
@@ -1488,9 +1488,9 @@ If the link is in hidden text, expose it."
 
 (defun org-link-descriptive-ensure ()
   "Toggle the literal or descriptive display of links in current buffer if needed."
-  (if org-link-descriptive
-      (org-fold-core-set-folding-spec-property (car org-link--link-folding-spec) :visible nil)
-    (org-fold-core-set-folding-spec-property (car org-link--link-folding-spec) :visible t)))
+  (org-fold-core-set-folding-spec-property
+   (car org-link--link-folding-spec)
+   :visible (not org-link-descriptive)))
 
 ;;;###autoload
 (defun org-toggle-link-display ()
diff --git a/lisp/org/org-clock.el b/lisp/org/org-clock.el
index f28805d5e6b..02cddddb304 100644
--- a/lisp/org/org-clock.el
+++ b/lisp/org/org-clock.el
@@ -3049,53 +3049,58 @@ PROPERTIES: The list properties specified in the `:properties' parameter
   "If this is a CLOCK line, update it and return t.
 Otherwise, return nil."
   (interactive)
-  (save-excursion
-    (beginning-of-line 1)
-    (skip-chars-forward " \t")
-    (when (looking-at org-clock-string)
-      (let ((re (concat "[ \t]*" org-clock-string
-			" *[[<]\\([^]>]+\\)[]>]\\(-+[[<]\\([^]>]+\\)[]>]"
-			"\\([ \t]*=>.*\\)?\\)?"))
-	    ts te h m s neg)
-	(cond
-	 ((not (looking-at re))
-	  nil)
-	 ((not (match-end 2))
-	  (when (and (equal (marker-buffer org-clock-marker) (current-buffer))
-		     (> org-clock-marker (point))
-                     (<= org-clock-marker (line-end-position)))
-	    ;; The clock is running here
-	    (setq org-clock-start-time
-		  (org-time-string-to-time (match-string 1)))
-	    (org-clock-update-mode-line)))
-	 (t
-          ;; Prevent recursive call from `org-timestamp-change'.
-          (cl-letf (((symbol-function 'org-clock-update-time-maybe) #'ignore))
-            ;; Update timestamps.
-            (save-excursion
-              (goto-char (match-beginning 1)) ; opening timestamp
-              (save-match-data (org-timestamp-change 0 'day)))
+  (let ((origin (point))) ;; `save-excursion' may not work when deleting.
+    (save-excursion
+      (beginning-of-line 1)
+      (skip-chars-forward " \t")
+      (when (looking-at org-clock-string)
+        (let ((re (concat "[ \t]*" org-clock-string
+		          " *[[<]\\([^]>]+\\)[]>]\\(-+[[<]\\([^]>]+\\)[]>]"
+		          "\\([ \t]*=>.*\\)?\\)?"))
+	      ts te h m s neg)
+          (cond
+	   ((not (looking-at re))
+	    nil)
+	   ((not (match-end 2))
+	    (when (and (equal (marker-buffer org-clock-marker) (current-buffer))
+		       (> org-clock-marker (point))
+                       (<= org-clock-marker (line-end-position)))
+	      ;; The clock is running here
+	      (setq org-clock-start-time
+		    (org-time-string-to-time (match-string 1)))
+	      (org-clock-update-mode-line)))
+	   (t
+            ;; Prevent recursive call from `org-timestamp-change'.
+            (cl-letf (((symbol-function 'org-clock-update-time-maybe) #'ignore))
+              ;; Update timestamps.
+              (save-excursion
+                (goto-char (match-beginning 1)) ; opening timestamp
+                (save-match-data (org-timestamp-change 0 'day)))
+              ;; Refresh match data.
+              (looking-at re)
+              (save-excursion
+                (goto-char (match-beginning 3)) ; closing timestamp
+                (save-match-data (org-timestamp-change 0 'day))))
             ;; Refresh match data.
             (looking-at re)
-            (save-excursion
-              (goto-char (match-beginning 3)) ; closing timestamp
-              (save-match-data (org-timestamp-change 0 'day))))
-          ;; Refresh match data.
-          (looking-at re)
-          (and (match-end 4) (delete-region (match-beginning 4) (match-end 4)))
-          (end-of-line 1)
-          (setq ts (match-string 1)
-                te (match-string 3))
-          (setq s (- (org-time-string-to-seconds te)
-		     (org-time-string-to-seconds ts))
-                neg (< s 0)
-                s (abs s)
-                h (floor (/ s 3600))
-                s (- s (* 3600 h))
-                m (floor (/ s 60))
-                s (- s (* 60 s)))
-	  (insert " => " (format (if neg "-%d:%02d" "%2d:%02d") h m))
-	  t))))))
+            (and (match-end 4) (delete-region (match-beginning 4) (match-end 4)))
+            (end-of-line 1)
+            (setq ts (match-string 1)
+                  te (match-string 3))
+            (setq s (- (org-time-string-to-seconds te)
+		       (org-time-string-to-seconds ts))
+                  neg (< s 0)
+                  s (abs s)
+                  h (floor (/ s 3600))
+                  s (- s (* 3600 h))
+                  m (floor (/ s 60))
+                  s (- s (* 60 s)))
+	    (insert " => " (format (if neg "-%d:%02d" "%2d:%02d") h m))
+	    t)))))
+    ;; Move back to initial position, but never beyond updated
+    ;; clock.
+    (unless (< (point) origin)
+      (goto-char origin))))
 
 (defun org-clock-save ()
   "Persist various clock-related data to disk.
diff --git a/lisp/org/org-element.el b/lisp/org/org-element.el
index 48ede9c5289..1f36775a7b5 100644
--- a/lisp/org/org-element.el
+++ b/lisp/org/org-element.el
@@ -5717,7 +5717,11 @@ This function assumes `org-element--headline-cache' is a valid AVL tree."
               ;; `combine-change-calls' because the buffer is potentially
               ;; changed without notice (the change will be registered
               ;; after exiting the `combine-change-calls' body though).
-              (memq #'org-element--cache-after-change after-change-functions))))))
+              (catch :inhibited
+                (org-fold-core-cycle-over-indirect-buffers
+                  (unless (memq #'org-element--cache-after-change after-change-functions)
+                    (throw :inhibited nil)))
+                t))))))
 
 ;; FIXME: Remove after we establish that hashing is effective.
 (defun org-element-cache-hash-show-statistics ()
diff --git a/lisp/org/org-fold-core.el b/lisp/org/org-fold-core.el
index be600f8a0cc..ffa689d4fa1 100644
--- a/lisp/org/org-fold-core.el
+++ b/lisp/org/org-fold-core.el
@@ -497,7 +497,7 @@ hanging around."
   (declare (debug (form body)) (indent 0))
   `(let (buffers dead-properties)
      (if (and (not (buffer-base-buffer))
-              (not (eq (current-buffer) (car org-fold-core--indirect-buffers))))
+              (not (memq (current-buffer) org-fold-core--indirect-buffers)))
          ;; We are in base buffer with `org-fold-core--indirect-buffers' value from
          ;; different buffer.  This can happen, for example, when
          ;; org-capture copies local variables into *Capture* buffer.
@@ -930,6 +930,8 @@ are provided.
 
 If FROM is non-nil and TO is nil, search the folded regions at FROM.
 
+When both FROM and TO are nil, search folded regions in the whole buffer.
+
 When SPECS is non-nil it should be a list of folding specs or a symbol.
 Only return the matching fold types.
 
@@ -946,6 +948,9 @@ WITH-MARKERS must be nil when RELATIVE is non-nil."
   (unless (listp specs) (setq specs (list specs)))
   (let (regions region mk-region)
     (org-with-wide-buffer
+     (when (and (not from) (not to))
+       (setq from (point-min)
+             to (point-max)))
      (when (and from (not to)) (setq to (point-max)))
      (when (and from (< from (point-min))) (setq from (point-min)))
      (when (and to (> to (point-max))) (setq to (point-max)))
@@ -1058,7 +1063,7 @@ means that the buffer should stay alive during the operation,
 because otherwise all these markers will point to nowhere."
   (declare (debug (form body)) (indent 1))
   (org-with-gensyms (regions)
-    `(let* ((,regions ,(org-fold-core-get-regions :with-markers use-markers)))
+    `(let* ((,regions (org-fold-core-get-regions :with-markers ,use-markers)))
        (unwind-protect (progn ,@body)
          (org-fold-core-regions ,regions :override t :clean-markers t)))))
 
diff --git a/lisp/org/org-footnote.el b/lisp/org/org-footnote.el
index aedd413351c..ac78360aeff 100644
--- a/lisp/org/org-footnote.el
+++ b/lisp/org/org-footnote.el
@@ -851,9 +851,12 @@ to `org-footnote-section'.  Inline definitions are ignored."
 			    (format "[fn:%s] DEFINITION NOT FOUND." label))
 			"\n"))))
 	  ;; Insert un-referenced footnote definitions at the end.
-	  (pcase-dolist (`(,label . ,definition) definitions)
-	    (unless (member label inserted)
-	      (insert "\n" definition "\n")))))))))
+          ;; Combine all insertions into one to create a single cache
+          ;; update call.
+          (combine-change-calls (point) (point)
+	    (pcase-dolist (`(,label . ,definition) definitions)
+	      (unless (member label inserted)
+	        (insert "\n" definition "\n"))))))))))
 
 (defun org-footnote-normalize ()
   "Turn every footnote in buffer into a numbered one."
diff --git a/lisp/org/org-persist.el b/lisp/org/org-persist.el
index 108292f1e92..1a32ed01020 100644
--- a/lisp/org/org-persist.el
+++ b/lisp/org/org-persist.el
@@ -161,7 +161,7 @@
 (declare-function org-at-heading-p "org" (&optional invisible-not-ok))
 
 
-(defconst org-persist--storage-version "2.5"
+(defconst org-persist--storage-version "2.7"
   "Persistent storage layout version.")
 
 (defgroup org-persist nil
@@ -856,9 +856,16 @@ When IGNORE-RETURN is non-nil, just return t on success without calling
       (setq associated (org-persist--normalize-associated (get-file-buffer (plist-get associated :file)))))
     (let ((collection (org-persist--get-collection container associated)))
       (setf collection (plist-put collection :associated associated))
-      (unless (seq-find (lambda (v)
-                          (run-hook-with-args-until-success 'org-persist-before-write-hook v associated))
-                        (plist-get collection :container))
+      (unless (or
+               ;; Prevent data leakage from encrypted files.
+               ;; We do it in somewhat paranoid manner and do not
+               ;; allow anything related to encrypted files to be
+               ;; written.
+               (and (plist-get associated :file)
+                    (string-match-p epa-file-name-regexp (plist-get associated :file)))
+               (seq-find (lambda (v)
+                           (run-hook-with-args-until-success 'org-persist-before-write-hook v associated))
+                         (plist-get collection :container)))
         (when (or (file-exists-p org-persist-directory) (org-persist--save-index))
           (let ((file (org-file-name-concat org-persist-directory (plist-get collection :persist-file)))
                 (data (mapcar (lambda (c) (cons c (org-persist-write:generic c collection)))
diff --git a/lisp/org/org-table.el b/lisp/org/org-table.el
index 8e0e8e6cf86..fa9a0319be2 100644
--- a/lisp/org/org-table.el
+++ b/lisp/org/org-table.el
@@ -41,6 +41,7 @@
 (require 'org-macs)
 (require 'org-compat)
 (require 'org-keys)
+(require 'org-fold-core)
 
 (declare-function calc-eval "calc" (str &optional separator &rest args))
 (declare-function face-remap-remove-relative "face-remap" (cookie))
@@ -4448,6 +4449,13 @@ FIELD is a string.  WIDTH is a number.  ALIGN is either \"c\",
 (defun org-table-justify-field-maybe (&optional new)
   "Justify the current field, text to left, number to right.
 Optional argument NEW may specify text to replace the current field content."
+  ;; FIXME: Prevent newlines inside field.  They are currently not
+  ;; supported.
+  (when (and (stringp new) (string-match-p "\n" new))
+    (message "Removing newlines from formula result: %S" new)
+    (setq new (replace-regexp-in-string
+               "\n" " "
+               (replace-regexp-in-string "\\(^\n+\\)\\|\\(\n+$\\)" "" new))))
   (cond
    ((and (not new) org-table-may-need-update)) ; Realignment will happen anyway
    ((org-at-table-hline-p))
@@ -5721,31 +5729,32 @@ This may be either a string or a function of two arguments:
     ;; Initialize communication channel in INFO.
     (with-temp-buffer
       (let ((org-inhibit-startup t)) (org-mode))
-      (let ((standard-output (current-buffer))
-	    (org-element-use-cache nil))
-	(dolist (e table)
-	  (cond ((eq e 'hline) (princ "|--\n"))
-		((consp e)
-		 (princ "| ") (dolist (c e) (princ c) (princ " |"))
-		 (princ "\n")))))
-      (org-element-cache-reset)
-      ;; Add back-end specific filters, but not user-defined ones.  In
-      ;; particular, make sure to call parse-tree filters on the
-      ;; table.
-      (setq info
-	    (let ((org-export-filters-alist nil))
-	      (org-export-install-filters
-	       (org-combine-plists
-		(org-export-get-environment backend nil params)
-		`(:back-end ,(org-export-get-backend backend))))))
-      (setq data
-	    (org-export-filter-apply-functions
-	     (plist-get info :filter-parse-tree)
-	     (org-element-map (org-element-parse-buffer) 'table
-	       #'identity nil t)
-	     info)))
-    (when (and backend (symbolp backend) (not (org-export-get-backend backend)))
-      (user-error "Unknown :backend value"))
+      (org-fold-core-ignore-modifications
+        (let ((standard-output (current-buffer))
+	      (org-element-use-cache nil))
+	  (dolist (e table)
+	    (cond ((eq e 'hline) (princ "|--\n"))
+		  ((consp e)
+		   (princ "| ") (dolist (c e) (princ c) (princ " |"))
+		   (princ "\n")))))
+        (org-element-cache-reset)
+        ;; Add back-end specific filters, but not user-defined ones.  In
+        ;; particular, make sure to call parse-tree filters on the
+        ;; table.
+        (setq info
+	      (let ((org-export-filters-alist nil))
+	        (org-export-install-filters
+	         (org-combine-plists
+		  (org-export-get-environment backend nil params)
+		  `(:back-end ,(org-export-get-backend backend))))))
+        (setq data
+	      (org-export-filter-apply-functions
+	       (plist-get info :filter-parse-tree)
+	       (org-element-map (org-element-parse-buffer) 'table
+	         #'identity nil t)
+	       info))
+        (when (and backend (symbolp backend) (not (org-export-get-backend backend)))
+          (user-error "Unknown :backend value"))))
     (when (or (not backend) (plist-get info :raw)) (require 'ox-org))
     ;; Handle :skip parameter.
     (let ((skip (plist-get info :skip)))
diff --git a/lisp/org/org-version.el b/lisp/org/org-version.el
index e9339690409..b9f8d5d66e7 100644
--- a/lisp/org/org-version.el
+++ b/lisp/org/org-version.el
@@ -11,7 +11,7 @@ Inserted by installing Org mode or when a release is made."
 (defun org-git-version ()
   "The Git version of Org mode.
 Inserted by installing Org or when a release is made."
-   (let ((org-git-version "release_9.6-3-ga4d38e"))
+   (let ((org-git-version "release_9.6-31-g954a95"))
      org-git-version))
 
 (provide 'org-version)
diff --git a/lisp/org/org.el b/lisp/org/org.el
index ab6212daccd..19f94c5e232 100644
--- a/lisp/org/org.el
+++ b/lisp/org/org.el
@@ -11380,7 +11380,7 @@ See also `org-scan-tags'."
 			     (pv (match-string 7 term))
 			     (regexp (eq (string-to-char pv) ?{))
 			     (strp (eq (string-to-char pv) ?\"))
-			     (timep (string-match-p "^\"[[<][0-9]+.*[]>]\"$" pv))
+			     (timep (string-match-p "^\"[[<]\\(?:[0-9]+\\|now\\|today\\|tomorrow\\|[+-][0-9]+[dmwy]\\).*[]>]\"$" pv))
 			     (po (org-op-to-function (match-string 6 term)
 						     (if timep 'time strp))))
 			(setq pv (if (or regexp strp) (substring pv 1 -1) pv))
@@ -16322,6 +16322,10 @@ buffer boundaries with possible narrowing."
 					  (org-element-property :end link))
 					 (skip-chars-backward " \t")
 					 (point)))))
+                              ;; FIXME: See bug#59902.  We cannot rely
+                              ;; on Emacs to update image if the file
+                              ;; has changed.
+                              (image-flush image)
 			      (overlay-put ov 'display image)
 			      (overlay-put ov 'face 'default)
 			      (overlay-put ov 'org-image-overlay t)
diff --git a/lisp/org/ox-md.el b/lisp/org/ox-md.el
index 01e0aa0491b..dcd95e98711 100644
--- a/lisp/org/ox-md.el
+++ b/lisp/org/ox-md.el
@@ -87,7 +87,8 @@ included into another document or application that reserves top-level
 headings for its own use."
   :group 'org-export-md
   :package-version '(Org . "9.6")
-  :type 'natnum)
+  ;; Avoid `natnum' because that's not available until Emacs 28.1.
+  :type 'integer)
 
 
 
diff --git a/lisp/org/ox.el b/lisp/org/ox.el
index f6629cde4dc..aed669ee87d 100644
--- a/lisp/org/ox.el
+++ b/lisp/org/ox.el
@@ -3036,6 +3036,11 @@ Return code as a string."
 	       (org-narrow-to-subtree)
 	       (goto-char (point-min))
 	       (org-end-of-meta-data)
+               ;; Make the region include top heading in the subtree.
+               ;; This way, we will be able to retrieve its export
+               ;; options when calling
+               ;; `org-export--get-subtree-options'.
+               (backward-char)
 	       (narrow-to-region (point) (point-max))))
         ;; Initialize communication channel with original buffer
         ;; attributes, unavailable in its copy.