Current File : //kunden/usr/share/emacs/27.2/lisp/org/org-macs.elc

;ELC
;;; Compiled
;;; in Emacs version 27.2
;;; with all optimizations.

;;; This file uses dynamic docstrings, first added in Emacs 19.29.

;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


(byte-code "\300\301!\210\300\302!\207" [require cl-lib format-spec] 2)
#@27 

(fn SYMBOLS &rest BODY)
(defalias 'org-with-gensyms '(macro . #[385 "\300\301\302\"BB\207" [let mapcar #[257 "\211\300\301\302\303\304DDEDD\207" [make-symbol concat "--" symbol-name quote] 8 "\n\n(fn S)"]] 6 (#$ . 480)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\300\207" [put org-with-gensyms edebug-form-spec (sexp body) function-put lisp-indent-function 1] 4)
#@84 Run BODY while preserving the buffer's `buffer-modified-p' state.

(fn &rest BODY)
(defalias 'org-unmodified '(macro . #[128 "\300\301!\302
\303BC\304\302\305BB\306DEE\207" [make-symbol "--was-modified" let ((buffer-modified-p)) unwind-protect ((buffer-undo-list t) (inhibit-modification-hooks t)) set-buffer-modified-p] 8 (#$ . 865)]))
(put 'org-unmodified 'edebug-form-spec '(body))
#@19 

(fn &rest BODY)
(defalias 'org-without-partial-completion '(macro . #[128 "\300\301\302\303\304BB\305BBBBB\207" [if (and (boundp 'partial-completion-mode) partial-completion-mode (fboundp 'partial-completion-mode)) unwind-protect progn (partial-completion-mode -1) ((partial-completion-mode 1))] 7 (#$ . 1259)]))
(put 'org-without-partial-completion 'edebug-form-spec '(body))
#@96 Move to buffer and point of point-or-marker POM for the duration of BODY.

(fn POM &rest BODY)
(defalias 'org-with-point-at '(macro . #[385 "\300\301!\302
DC\303\304\305D\306\307DDE\310\311\312\313BBDBBEE\207" [make-symbol "--mpom" let save-excursion when markerp set-buffer marker-buffer org-with-wide-buffer goto-char or ((point))] 12 (#$ . 1646)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\300\207" [put org-with-point-at edebug-form-spec (form body) function-put lisp-indent-function 1] 4)
#@87 Execute BODY while recording undo information in two buffers.

(fn BUFFER &rest BODY)
(defalias 'org-with-remote-undo '(macro . #[385 "\300\301!\300\302!\300\303!\300\304!\300\305!\300\306!\300\307!\300\310!\311\312B\313B\314BD\315B\316\317BBD\257\320\321\322\323\324\f\316\325BBE	\324
\316\326BBE\257\321\327\n\nE\330\316\331BBE\330\316\332BBE\333\334\257\335BB\257FC\"BB\207" [make-symbol "--cline" "--cmd" "--buf1" "--buf2" "--undo1" "--undo2" "--c1" "--c2" let ((org-current-line)) (this-command) ((current-buffer)) (buffer-undo-list) with-current-buffer (buffer-undo-list) append when org-agenda-allow-remote-undo setq org-verify-change-for-undo (buffer-undo-list) (buffer-undo-list) or and ((undo-boundary)) ((undo-boundary)) push list (org-agenda-undo-list)] 29 (#$ . 2164)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\300\207" [put org-with-remote-undo edebug-form-spec (form body) function-put lisp-indent-function 1] 4)
#@46 Inhibit read-only for BODY.

(fn &rest BODY)
(defalias 'org-no-read-only '(macro . #[128 "\300\301BB\207" [let ((inhibit-read-only t))] 4 (#$ . 3166)]))
(put 'org-no-read-only 'edebug-form-spec '(body))
#@329 Save and restore outline visibility around BODY.
If USE-MARKERS is non-nil, use markers for the positions.  This
means that the buffer may change while running BODY, but it also
means that the buffer should stay alive during the operation,
because otherwise all these markers will point to nowhere.

(fn USE-MARKERS &rest BODY)
(defalias 'org-save-outline-visibility '(macro . #[385 "\300\301!\300\302!\300\303!\304\305BD\306\307\310\311\312\313\314\315\316\317\320E\321\322\323BB\322\324BB\325BBB\257EE\326BBDE\327\330B\331\332\320D\333BB\334\335\336\337\fED\340\341\n\342BBFEEE\207" [make-symbol "--data" "--invisible-types" "--markers?" let* ('(org-hide-block outline)) mapcar lambda (o) let ((beg (overlay-start o)) (end (overlay-end o)) (type (overlay-get o 'invisible))) and beg end (> end beg) memq type list if ((copy-marker beg) beg) ((copy-marker end t) end) (type) ((org-with-wide-buffer (overlays-in (point-min) (point-max)))) unwind-protect progn org-with-wide-buffer dolist ((remove-overlays (point-min) (point-max) 'invisible type)) pcase-dolist `(,beg ,end ,type) delq nil (org-flag-region beg end t type) when ((set-marker beg nil) (set-marker end nil))] 24 (#$ . 3377)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\300\207" [put org-save-outline-visibility edebug-form-spec (form body) function-put lisp-indent-function 1] 4)
#@70 Execute body while temporarily widening the buffer.

(fn &rest BODY)
(defalias 'org-with-wide-buffer '(macro . #[128 "\300\301\302BBD\207" [save-excursion save-restriction (widen)] 5 (#$ . 4753)]))
(put 'org-with-wide-buffer 'edebug-form-spec '(body))
#@70 Execute BODY with limited number of outline levels.

(fn &rest BODY)
(defalias 'org-with-limited-levels '(macro . #[128 "\300\301\302\303\304\305\306BB\257\207" [progn (defvar org-called-with-limited-levels) (defvar org-outline-regexp) (defvar outline-regexp) (defvar org-outline-regexp-bol) let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp)))] 9 (#$ . 5012)]))
(put 'org-with-limited-levels 'edebug-form-spec '(body))
#@25 

(fn ENVIRONMENT FORM)
(defalias 'org-eval-in-environment '(macro . #[514 "\300\301\302\303DFD\207" [eval list 'let quote] 8 (#$ . 5577)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\300\207" [put org-eval-in-environment edebug-form-spec (form form) function-put lisp-indent-function 1] 4)
#@70 Load FILE with optional arguments NOERROR and MUSTSUFFIX.

(fn FILE)
(defalias 'org-load-noerror-mustsuffix '(macro . #[257 "\300
\301BB\207" [load ('noerror nil nil 'mustsuffix)] 4 (#$ . 5884)]))
#@65 Execute BODY while preserving local variables.

(fn &rest BODY)
(defalias 'org-preserve-local-variables '(macro . #[128 "\300\301\302\303B\304BBE\207" [let ((local-variables (org-with-wide-buffer (goto-char (point-max)) (let ((case-fold-search t)) (and (re-search-backward "^[ 	]*# +Local Variables:" (max (- (point) 3000) 1) t) (delete-and-extract-region (point) (point-max))))))) unwind-protect progn ((when local-variables (org-with-wide-buffer (goto-char (point-max)) (let ((overlay (cl-find-if (lambda (o) (eq 'outline (overlay-get o 'invisible))) (overlays-at (1- (point)))))) (unless (bolp) (insert "\n")) (insert local-variables) (when overlay (move-overlay overlay (overlay-start overlay) (point-max)))))))] 6 (#$ . 6087)]))
(put 'org-preserve-local-variables 'edebug-form-spec '(body))
#@60 Suppress popup windows and evaluate BODY.

(fn &rest BODY)
(defalias 'org-no-popups '(macro . #[128 "\300\301BB\207" [let (pop-up-frames display-buffer-alist)] 4 (#$ . 6890)]))
#@88 Return the base buffer of BUFFER, if it has one.  Else return the buffer.

(fn BUFFER)
(defalias 'org-base-buffer #[257 "\211\205\300
!\206\211\207" [buffer-base-buffer] 3 (#$ . 7074)])
#@102 Like `find-buffer-visiting' but always return the base buffer and
not an indirect buffer.

(fn FILE)
(defalias 'org-find-base-buffer-visiting #[257 "\300
!\206	\301
!\302
!\207" [get-file-buffer find-buffer-visiting org-base-buffer] 4 (#$ . 7271)])
#@153 Switch to buffer in a second window on the current frame.
In particular, do not allow pop-up frames.
Returns the newly created buffer.

(fn &rest ARGS)
(defalias 'org-switch-to-buffer-other-window #[128 "\302\211\303\304\"*\207" [display-buffer-alist pop-up-frames nil apply switch-to-buffer-other-window] 4 (#$ . 7528)])
#@360 Fit WINDOW to the buffer, but only if it is not a side-by-side window.
WINDOW defaults to the selected window.  MAX-HEIGHT and MIN-HEIGHT are
passed through to `fit-window-to-buffer'.  If SHRINK-ONLY is set, call
`shrink-window-if-larger-than-buffer' instead, the height limit is
ignored in this case.

(fn &optional WINDOW MAX-HEIGHT MIN-HEIGHT SHRINK-ONLY)
(defalias 'org-fit-window-to-buffer #[1024 "\300\301!\203
\301!?\202\302 \303!V\2043\300\304!\203)\211\204)\304#\210\2023\300\305!\2033\305!\210\2069\306 \207" [fboundp window-full-width-p frame-width window-width fit-window-to-buffer shrink-window-if-larger-than-buffer selected-window] 8 (#$ . 7860)])
#@152 Non-nil if FILE is newer than TIME.
FILE is a filename, as a string, TIME is a list of integers, as
returned by, e.g., `current-time'.

(fn FILE TIME)
(defalias 'org-file-newer-than-p #[514 "\300!\205\301\302\303\304!8\305\306#\302\305\306#\"?\207" [file-exists-p time-less-p cl-subseq 5 file-attributes 0 2] 8 (#$ . 8546)])
#@1200 Compile a SOURCE file using PROCESS.

PROCESS is either a function or a list of shell commands, as
strings.  EXT is a file extension, without the leading dot, as
a string.  It is used to check if the process actually succeeded.

PROCESS must create a file with the same base name and directory
as SOURCE, but ending with EXT.  The function then returns its
filename.  Otherwise, it raises an error.  The error message can
then be refined by providing string ERR-MSG, which is appended to
the standard message.

If PROCESS is a function, it is called with a single argument:
the SOURCE file.

If it is a list of commands, each of them is called using
`shell-command'.  By default, in each command, %b, %f, %F, %o and
%O are replaced with, respectively, SOURCE base name, name, full
name, directory and absolute output file name.  It is possible,
however, to use more place-holders by specifying them in optional
argument SPEC, as an alist following the pattern

  (CHARACTER . REPLACEMENT-STRING).

When PROCESS is a list of commands, optional argument LOG-BUF can
be set to a buffer or a buffer name.  `shell-command' then uses
it for output.

(fn SOURCE PROCESS EXT &optional ERR-MSG LOG-BUF SPEC)
(defalias 'org-compile-file #[1539 "\300!\301!\302!\206\303\304\305	Q\"\306 ;\203'\307P\202(\310\311 \312\313\314\315\316!\317\"\320$\216\321\f!\203H\322!!\210\202\253:\203\244\205W\323	!\324	\325\322!B\326\322!B\327\322\f!B\330\322\f!B\331\322\f!B\257\"
\211\203\222\211@\332\333\"\"\210
A\266\202\202}\210
\203\237r
q\210\334 \210)\266\202\253\335\336#\210)\210\337\"\204\274\335\340\341#!\210\207" [file-name-base file-truename file-name-directory "./" expand-file-name "." current-time ".  " "" current-window-configuration make-byte-code 0 "\301\300!\207" vconcat vector [set-window-configuration] 2 functionp shell-quote-argument get-buffer-create append 98 102 70 111 79 shell-command format-spec compilation-mode error "No valid command to process %S%s" org-file-newer-than-p format "File %S wasn't produced%s"] 23 (#$ . 8884)])
#@214 Remove the maximum common indentation from the buffer.
When optional argument N is a positive integer, remove exactly
that much characters from indentation, if possible.  Return nil
if it fails.

(fn &optional N)
(defalias 'org-do-remove-indentation #[256 "\3002seb\210\211\2062d\212\301\302\303\304#\203.\305 \211\306U\203%\307\300\303\"\210\202*

^\262\210\202
)\211\262
\211\306U\203?\307\300\303\"\202pm\204o\310\303w\210il\203T\311 `|\210\202h\211W\203b\307\300\303\"\210\202h\312
Z!\210\303y\266\202?\304\262
0\207" [:exit re-search-forward "^[ 	]*\\S-" nil t current-indentation 0 throw " 	" line-beginning-position indent-line-to] 6 (#$ . 10986)])
#@161 Prompt for a function.
If ALLOW-EMPTY? is non-nil, return nil rather than raising an
error when the user input is empty.

(fn PROMPT &optional ALLOW-EMPTY\=\?)
(defalias 'org-read-function #[513 "\301\302\303$\211\304\230\204\305
!\202
\203\306\202\307\310!\207" [obarray completing-read fboundp t "" intern nil user-error "Empty input is not valid"] 7 (#$ . 11667)])
#@71 Completing-read with SPACE being a normal character.

(fn &rest ARGS)
(defalias 'org-completing-read #[128 "\302\303!\304\305\306#\210\304\307\306#\210\304\310\311#\210\312\313\"*\207" [minibuffer-local-completion-map enable-recursive-minibuffers t copy-keymap define-key " " self-insert-command "?" "!" org-time-stamp-inactive apply completing-read] 5 (#$ . 12051)])
#@200 Read a key and ensure it is a member of ALLOWED-KEYS.
Enable keys to scroll the window if NAVIGATION-KEYS is set.
TAB, SPC and RET are treated equivalently.

(fn ALLOWED-KEYS PROMPT NAVIGATION-KEYS)
(defalias 'org--mks-read-key #[771 "\211\205\301\302!
\203\211\303>\203\304
!\210\305#\202J\306\307\310\"\203+\311\202/
\211\262
!\211\235\203:\211\202H\312\313\"\210\314\315!\210\305#\262
\207" [header-line-format "Use C-n, C-p, C-v, M-v to navigate." read-char-exclusive (14 16 22 134217846) org-scroll org--mks-read-key char-to-string memql (13 9 32) 9 message "Invalid key: `%s'" sit-for 1] 9 (#$ . 12434)])
#@1149 Select a member of an alist with multiple keys.

TABLE is the alist which should contain entries where the car is a string.
There should be two types of entries.

1. prefix descriptions like ("a" "Description")
   This indicates that `a' is a prefix key for multi-letter selection, and
   that there are entries following with keys like "ab", "ax"...

2. Select-able members must have more than two elements, with the first
   being the string of keys that lead to selecting it, and the second a
   short description string of the item.

The command will then make a temporary buffer listing all entries
that can be selected with a single key, and all the single key
prefixes.  When you press the key for a single-letter entry, it is selected.
When you press a prefix key, the commands (and maybe further prefixes)
under this key will be shown and offered for selection.

TITLE will be placed over the selection in the temporary buffer,
PROMPT will be used when prompting for a key.  SPECIALS is an
alist with ("key" "description") entries.  When one of these
is selected, only the bare key is returned.

(fn TABLE TITLE &optional PROMPT SPECIALS)
(defalias 'org-mks #[1026 "\303 \304\305\306\307\310!\311\"\312$\216\313\314\315!\206\316\317\211
\304\305\320\307\310!\321\"\312$\216\3222a
\323 \210\324\261\210\317\325\326\317\327\330\203I\331!\202J\332\"\203U\333P\202V\332\211\203\324\211@\211:\203\315\211@\334\"\203\314
A\211:\203\313\211@
A\211\204\257
\335\336\"\211B\262\211\f\235\203\227\337
B\262
\202\235\211
B\262
	\340\341\342\343\342\344\261	\266\202\311
\335\336\"	\340\341\345\344\261\210\211
B\262
\266\266\210\210
A\266\202\202X\266	\203
\346c\210	\211\203
\211@\211@
A\211@
A
\327\347#c\210\211\nB\262\n\266
A\266\202\202\340\210eb\210\350 \210\351\332!\210\352\353dS!?#
P\262\211\354\232\203-
\355\356!\210\202Z
\211\235\204Z
\357\"\211\205@
\360\322\"\262
\204Z
\357\f\"\203V
\360\322\"\210\202Z
\361\362!\210\210)\266\202.+\266\205)\207" [case-fold-search inhibit-quit cursor-type current-window-configuration make-byte-code 0 "\301\300!\207" vconcat vector [set-window-configuration] 2 t org-switch-to-buffer-other-window "*Org Select*" "Select: " nil "\300\205\301\300!\207" [kill-buffer] exit erase-buffer "\n\n" ("") (" " "	" "
") format "\\`%s\\(.\\)\\'" regexp-quote "" " " string-match match-string 1 "	" "[" "]" "..." "  " "\n" "     " "-------------------------------------------------------------------------------\n" "[%s]     %s\n" org-fit-window-to-buffer message org--mks-read-key pos-visible-in-window-p "" user-error "Abort" assoc throw error "No entry available"] 33 (#$ . 13075)])
#@19 

(fn OPTION KEY)
(defalias 'org-get-alist-option #[514 "\211\300=\203\300\207
\300=\203\300\207\301
\"\203\301
\"A\207\302\236A\211<\203-\303\304\"\202.\211\207" [t assoc default delq nil] 6 (#$ . 15790)])
(put 'org-get-alist-option 'byte-optimizer 'byte-compile-inline-expand)
#@45 Return the last element of LIST.

(fn LIST)
(defalias 'org-last #[257 "\300
!@\207" [last] 3 (#$ . 16087)])
(put 'org-last 'byte-optimizer 'byte-compile-inline-expand)
#@67 Non-destructively remove duplicate elements from LIST.

(fn LIST)
(defalias 'org-uniquify #[257 "\300
!\301
!\207" [copy-sequence delete-dups] 4 (#$ . 16261)])
(put 'org-uniquify 'byte-optimizer 'byte-compile-inline-expand)
#@228 Merge elements of ALIST with the same key.

For example, in this alist:

(org-uniquify-alist \='((a 1) (b 2) (a 3)))
  => \='((a 1 3) (b 2))

merge (a 1) and (a 3) into (a 1 3).

The function returns the new ALIST.

(fn ALIST)
(defalias 'org-uniquify-alist #[257 "\300
\211\203=\211@\300\301@\"\204
B\262\2025
@\302\301@\"AA\"B\262
\303@\"\262\211B\262\210
A\266\202\202
\262
\207" [nil assoc append assq-delete-all] 10 (#$ . 16492)])
#@177 Remove all elements in ELTS from LIST.
Comparison is done with `equal'.  It is a destructive operation
that may remove elements by altering the list structure.

(fn ELTS LIST)
(defalias 'org-delete-all #[514 "
\203\300\211A\262\242\"\262
\202\207" [delete] 5 (#$ . 16953)])
#@97 Delete PROPERTY from PLIST.
This is in contrast to merely setting it to 0.

(fn PLIST PROPERTY)
(defalias 'org-plist-delete #[514 "\300\203
@=\204\301
@A@#\262
AA\262\202
\211\207" [nil plist-put] 7 (#$ . 17240)])
#@272 Create a single property list from all plists in PLISTS.
The process starts by copying the first list, and then setting properties
from the other lists.  Settings in the last list are the most significant
ones and overrule settings in the other lists.

(fn &rest PLISTS)
(defalias 'org-combine-plists #[128 "\300
\211A\262\242!\301\211\211\2035\211A\262\242\262
\211\203\211
A\262\242\262\211
A\262\242\262\302#\262\202\207" [copy-sequence nil plist-put] 9 (#$ . 17472)])
#@71 List of local variables that cannot be transferred to another buffer.
(defconst org-unique-local-variables '(org-element--cache org-element--cache-objects org-element--cache-sync-keys org-element--cache-sync-requests org-element--cache-sync-timer) (#$ . 17968))
#@61 Return a list of all local variables in an Org mode buffer.
(defalias 'org-get-local-variables #[0 "\300\301\302\303\304\305!r\211q\210\306\307\310\311\312!\313\"\314$\216\315 \210\316 *\262
\"\"\207" [delq nil mapcar #[257 "\2119\203\n\211C\202\211@
AD\211@\211\302N?\2052\211>?\2052\303\304!\305\306\307#)\266\203\2052
\207" [org-unique-local-variables inhibit-changing-match-data org-state "\\`\\(org-\\|orgtbl-\\|outline-\\|comment-\\|paragraph-\\|auto-fill\\|normal-auto-fill\\|fill-paragraph\\|indent-\\)" symbol-name nil t string-match] 10 "\n\n(fn X)"] generate-new-buffer " *temp*" make-byte-code 0 "\301\300!\205	\302\300!\207" vconcat vector [buffer-name kill-buffer] 2 org-mode buffer-local-variables] 11 (#$ . 18236)])
#@129 Clone local variables from FROM-BUFFER.
Optional argument REGEXP selects variables to clone.

(fn FROM-BUFFER &optional REGEXP)
(defalias 'org-clone-local-variables #[513 "\302!\211\205M\211@\211:\203F\211@
A\211\211>\204D\2032\303!\304\305\306#)\266\203\203D\3071?\310
!L0\202C\210\202D\210\266
A\266\202\202\207" [org-unique-local-variables inhibit-changing-match-data buffer-local-variables symbol-name nil t string-match (error) make-local-variable] 15 (#$ . 18989)])
#@79 Call COMMAND interactively, but pretend prefix arg was ARG.

(fn COMMAND ARG)
(defalias 'org-call-with-arg #[514 "\211\301!)\207" [current-prefix-arg call-interactively] 4 (#$ . 19491)])
(put 'org-call-with-arg 'byte-optimizer 'byte-compile-inline-expand)
#@347 Check if external program CMD for USE exists, error if not.
When the program does exist, return its path.
When it does not exist and NO-ERROR is set, return nil.
Otherwise, throw an error.  The optional argument USE can describe what this
program is needed for, so that the error message can be more informative.

(fn CMD &optional USE NO-ERROR)
(defalias 'org-check-external-command #[769 "\300!\206\211?\205\301\302\203\303\304\"\202\305#\207" [executable-find error "Can't find `%s'%s" format " (%s)" ""] 9 (#$ . 19756)])
(put 'org-check-external-command 'byte-optimizer 'byte-compile-inline-expand)
#@55 Display the given MESSAGE as a warning.

(fn MESSAGE)
(defalias 'org-display-warning #[257 "\300\301\302#\207" [display-warning org :warning] 5 (#$ . 20378)])
#@84 Display a message, but avoid logging it in the *Messages* buffer.

(fn &rest ARGS)
(defalias 'org-unlogged-message #[128 "\301\302\303\")\207" [message-log-max nil apply message] 4 (#$ . 20544)])
#@24 

(fn LIST &rest BODY)
(defalias 'org-let #[385 "\300\301BB!\207" [eval let] 6 (#$ . 20748)])
(put 'org-let 'lisp-indent-function 1)
#@31 

(fn LIST1 LIST2 &rest BODY)
(defalias 'org-let2 #[642 "\300\301\301BBCBB!\207" [eval let] 9 (#$ . 20889)])
(put 'org-let2 'lisp-indent-function 2)
#@41 Eval FORM and return result.

(fn FORM)
(defalias 'org-eval #[257 "\3001	\301
!0\207\302\303\"\207" [(error) eval format "%%![Error: %s]"] 5 (#$ . 21047)])
#@120 Return outline-regexp with limited number of levels.
The number of levels is controlled by `org-inlinetask-min-level'.
(defalias 'org-get-limited-outline-regexp #[0 "\304\305!\204\207\306\307!\204	\207\nS\203\211\310_S\202\211\311\312\"\207" [outline-regexp org-outline-regexp org-inlinetask-min-level org-odd-levels-only derived-mode-p org-mode featurep org-inlinetask 2 format "\\*\\{1,%d\\} "] 5 (#$ . 21212)])
#@127 Is the Nth next line empty?
Counts the current line as N = 1 and the previous line as N = 0;
see `beginning-of-line'.

(fn N)
(defalias 'org--line-empty-p #[257 "o?\205\212\301
!\210\302\303\304
!)\262
)\207" [inhibit-changing-match-data beginning-of-line "[ 	]*$" t looking-at] 4 (#$ . 21644)])
#@87 Is the previous line a blank line?
When NEXT is non-nil, check the next line instead.
(defalias 'org-previous-line-empty-p #[0 "\300\301!\207" [org--line-empty-p 0] 2 (#$ . 21949)])
#@87 Is the previous line a blank line?
When NEXT is non-nil, check the next line instead.
(defalias 'org-next-line-empty-p #[0 "\300\301!\207" [org--line-empty-p 2] 2 (#$ . 22137)])
#@10 

(fn N)
(defalias 'org-goto-line #[257 "\214~\210eb\210\211Sy)\207" [] 2 (#$ . 22321)])
(put 'org-goto-line 'byte-optimizer 'byte-compile-inline-expand)
#@22 

(fn &optional POS)
(defalias 'org-current-line #[256 "\212\211\203\211b\210n\203\300\202\301\302\300`\"\\)\207" [1 0 count-lines] 5 (#$ . 22481)])
(put 'org-current-line 'byte-optimizer 'byte-compile-inline-expand)
#@82 Make overlay OVL display TEXT with face FACE.

(fn OVL TEXT &optional FACE EVAP)
(defalias 'org-overlay-display #[1026 "\300\301#\210
\203\300\302#\210\211\205\300\303\304#\207" [overlay-put display face evaporate t] 8 (#$ . 22710)])
#@82 Make overlay OVL display TEXT with face FACE.

(fn OVL TEXT &optional FACE EVAP)
(defalias 'org-overlay-before-string #[1026 "
\203\300\301\302$\210\303\304#\210\211\205\303\305\306#\207" [org-add-props nil face overlay-put before-string evaporate t] 9 (#$ . 22959)])
#@133 Find all overlays specifying PROP at POS or point.
If DELETE is non-nil, delete all those overlays.

(fn PROP &optional POS DELETE)
(defalias 'org-find-overlays #[769 "\300\301\206`!\211\203-\211@\302
\"\203&\203!\303
!\210\202&\211B\262
A\266\202\202
\262
\207" [nil overlays-at overlay-get delete-overlay] 9 (#$ . 23243)])
#@124 Hide or show lines from FROM to TO, according to FLAG.
SPEC is the invisibility spec, as a symbol.

(fn FROM TO FLAG SPEC)
(defalias 'org-flag-region #[1028 "\300\301$\210
\205$\302\303\304$\305
\306\307#\210\305
\301#\210\305
\310\311#\262
\207" [remove-overlays invisible make-overlay nil front-advance overlay-put evaporate t isearch-open-invisible #[128 "\300\301!\207" [org-show-context isearch] 3 "\n\n(fn &rest _)"]] 9 (#$ . 23589)])
#@14 

(fn POS N)
(defalias 'org-pos-in-match-range #[514 "\211\224\205\211\224X\205\211\225Y\207" [] 4 (#$ . 24043)])
(put 'org-pos-in-match-range 'byte-optimizer 'byte-compile-inline-expand)
#@47 Skip over space, tabs and newline characters.
(defalias 'org-skip-whitespace #[0 "\300\301w\207" [" 	\n
" nil] 2 (#$ . 24243)])
#@65 Match REGEXP at the beginning of the current line.

(fn REGEXP)
(defalias 'org-match-line #[257 "\212\300 \210\301
!)\207" [beginning-of-line looking-at] 3 (#$ . 24377)])
#@64 Non-nil if regexp RE matches an element in LIST.

(fn RE LIST)
(defalias 'org-match-any-p #[514 "\300\301\302\303\304\305!\306\"\307\310%\"\207" [cl-some make-byte-code 257 "\300
\302\303\304#)\207" vconcat vector [inhibit-changing-match-data nil t string-match] 8 "\n\n(fn X)"] 9 (#$ . 24554)])
#@457 Check if point is inside a match of REGEXP.

Normally only the current line is checked, but you can include
NLINES extra lines around point into the search.  If VISUALLY is
set, require that the cursor is not after the match but really
on, so that the block visually is on the match.

Return nil or a cons cell (BEG . END) where BEG and END are,
respectively, the positions at the beginning and the end of the
match.

(fn REGEXP &optional NLINES VISUALLY)
(defalias 'org-in-regexp #[769 "\3002N`\301\203T\202\302!\212\303\302\206\304Z!\210\305\306#\205J\304\224X\205J\304\225\211V\204=\211U\203F\204F\307\300\304\224\304\225B\"\210\210\202)\266\2020\207" [:exit line-end-position 1 beginning-of-line 0 re-search-forward t throw] 10 (#$ . 24864)])
#@234 Check if POINT is in match-group GROUP.
If CONTEXT is non-nil, return a list with CONTEXT and the boundaries of the
match.  If the match group does not exist or point is not inside it,
return nil.

(fn POINT GROUP &optional CONTEXT)
(defalias 'org-point-in-group #[770 "
\224\205\224Y\205\225X\205\211\203\211\224\225E\207\300\207" [t] 6 (#$ . 25641)])
#@12 

(fn A B)
(defalias 'org-string< #[514 "\300\"\207" [org-string-collate-lessp] 5 (#$ . 26014)])
#@12 

(fn A B)
(defalias 'org-string<= #[514 "

\230\206\n\300\"\207" [org-string-collate-lessp] 5 (#$ . 26119)])
#@12 

(fn A B)
(defalias 'org-string>= #[514 "\300\"?\207" [org-string-collate-lessp] 5 (#$ . 26238)])
#@12 

(fn A B)
(defalias 'org-string> #[514 "

\230?\205\f\300\"?\207" [org-string-collate-lessp] 5 (#$ . 26345)])
#@12 

(fn A B)
(defalias 'org-string<> #[514 "

\230?\207" [] 4 (#$ . 26465)])
#@223 Remove whitespace at the beginning and the end of string S.
When optional argument KEEP-LEAD is non-nil, removing blank lines
at the beginning of the string does not affect leading indentation.

(fn S &optional KEEP-LEAD)
(defalias 'org-trim #[513 "\300
\203	\301\202\n\302\303\300\304\303##\207" [replace-regexp-in-string "\\`\\([ 	]*\n\\)+" "\\`[ 	\n
]+" "" "[ 	\n
]+\\'"] 9 (#$ . 26547)])
(put 'org-trim 'byte-optimizer 'byte-compile-inline-expand)
#@92 Return S if S is a string containing a non-blank character.
Otherwise, return nil.

(fn S)
(defalias 'org-string-nw-p #[257 "\211;\205\301
\302\303\304#)\266\203\205\211\207" [inhibit-changing-match-data "[^ 
	\n]" nil t string-match] 8 (#$ . 27009)])
#@44 Return the reverse of STRING.

(fn STRING)
(defalias 'org-reverse-string #[257 "\300\301\302
\303\"\262
\237\"\207" [apply string append nil] 7 (#$ . 27275)])
#@248 Splits STRING into substrings at SEPARATORS.

SEPARATORS is a regular expression.  When nil, it defaults to
"[ 	

]+".

Unlike `split-string', matching SEPARATORS at the beginning and
end of string are ignored.

(fn STRING &optional SEPARATORS)
(defalias 'org-split-string #[513 "\211\206\300\301
\"\204C\202P\302\225\302\224\302U?\205\"\303\302\211\224#C\301#\203<\303\302\224#
B\262
\302\225\262\202\"
GU\203G\211\202M\303\"
B\237\266\202\207" ["[ \f	\n
]+" string-match 0 substring] 9 (#$ . 27442)])
#@201 Return the visible part of string S.
Visible part is determined according to text PROPERTY, which is
either `invisible' or `display'.  BEG and END are 0-indices
delimiting S.

(fn S PROPERTY BEG END)
(defalias 'org--string-from-props #[1028 "\301\302\303\n%\211\262\203\314\304$\305\"\306
\"\307\267\202\212\310=\2048\311
\"\205\217\301\202\217\211\204D\303\202\217\211:\203w\211@\211\312\267\202q
A\211\306
\313\"\314
!\205_\211\262
\262
\262
\202r\315\316!@!\202r\303\262
\202\217\211;\203\206\317
\320\301G$\202\217\303\202\217\321\322	\"\211\203\304	\323=\203\247\317\320\f$\202\274	U\203\262\301\202\274\324\325\f\f#!\\\\\262\262\262\266\202
\323=\203\336\317\320$\202\361
U\203\350\301\202\361\324\325#!\\\207" [buffer-invisibility-spec 0 text-property-not-all nil next-single-property-change text-properties-at plist-get #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (invisible 43 display 60)) t assoc-string #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (space 81 image 104)) :width wholenump ceiling image-size org--string-from-props invisible error "Unknown property: %S" display string-width substring] 16 (#$ . 27978)])
#@333 Return width of STRING when displayed in the current buffer.
Unlike `string-width', this function takes into consideration
`invisible' and `display' text properties.  It supports the
latter in a limited way, mostly for combinations used in Org.
Results may be off sometimes if it cannot handle a given
`display' value.

(fn STRING)
(defalias 'org-string-width #[257 "\300
\301\302G$\207" [org--string-from-props display 0] 6 (#$ . 29280)])
#@91 If V not nil, and also not the string "nil", then return V.
Otherwise return nil.

(fn V)
(defalias 'org-not-nil #[257 "\211\205\f\211\300\232?\205\f\211\207" ["nil"] 3 (#$ . 29727)])
#@202 Remove PRE/POST from the beginning/end of STRING.
Both PRE and POST must be pre-/suffixes of STRING, or neither is
removed.  Return the new string.  If STRING is nil, return nil.

(fn PRE POST STRING)
(defalias 'org-unbracket-string #[771 "\211\205\300\"\203\301\"\203\302
GG[#\207\211\207" [string-prefix-p string-suffix-p substring] 7 (#$ . 29920)])
(byte-code "\300\301\302\303#\300\207" [function-put org-unbracket-string lisp-indent-function 2] 4)
#@99 Strip double quotes from around STRING, if applicable.
If STRING is nil, return nil.

(fn STRING)
(defalias 'org-strip-quotes #[257 "\300\301\211#\207" [org-unbracket-string "\""] 5 (#$ . 30391)])
#@150 Return current line, as a string.
If optional argument TO-HERE is non-nil, return string from
beginning of line up to point.

(fn &optional TO-HERE)
(defalias 'org-current-line-string #[256 "\300 
\203\n`\202\f\301 {\207" [line-beginning-position line-end-position] 3 (#$ . 30596)])
(put 'org-current-line-string 'byte-optimizer 'byte-compile-inline-expand)
#@508 Shorten string S so that it is no longer than MAXLENGTH characters.
If the string is shorter or has length MAXLENGTH, just return the
original string.  If it is longer, the functions finds a space in the
string, breaks this string off at that locations and adds three dots
as ellipsis.  Including the ellipsis, the string will not be longer
than MAXLENGTH.  If finding a good breaking point in the string does
not work, the string is just chopped off in the middle of a word
if necessary.

(fn S MAXLENGTH)
(defalias 'org-shorten-string #[514 "
G
X\203	
\207\211\300Z\301]\302\303!\304Q\305
\"\203$\306\301\"\307P\202/\310\311\312Z\311]#\307P\207" [4 1 "\\`\\(.\\{1," number-to-string "\\}[^ ]\\)\\([ ]\\|\\'\\)" string-match match-string "..." substring 0 3] 9 (#$ . 30963)])
#@117 Replace tabulators in S with spaces.
Assumes that s is a single line, starting in column 0.

(fn S &optional WIDTH)
(defalias 'org-remove-tabs #[513 "\211\206\262
\301\302\"\203&\303\304\305\224\\\245_\305\224Z\306\"\307\211$\262\202
\207" [tab-width string-match "	" replace-match make-string 0 32 t] 7 (#$ . 31755)])
#@470 Wrap string to either a number of lines, or a width in characters.
If WIDTH is non-nil, the string is wrapped to that width, however many lines
that costs.  If there is a word longer than WIDTH, the text is actually
wrapped to the length of that word.
IF WIDTH is nil and LINES is non-nil, the string is forced into at most that
many lines, whatever width that takes.
The return value is a list of lines, without newlines at the end.

(fn STRING &optional WIDTH LINES)
(defalias 'org-wrap #[769 "\300!\301\302\303\304\"\"\305\211\203\306]\"\202P\203M\262\306\"\262
\211GX\2032\211\202P\262
\211GV\203I
T\262\306\"\262
\2025\211\202P\307\310!\207" [split-string apply max mapcar org-string-width nil org--do-wrap error "Cannot wrap this"] 11 (#$ . 32093)])
#@93 Create lines of maximum width WIDTH (in characters) from word list WORDS.

(fn WORDS WIDTH)
(defalias 'org--do-wrap #[514 "\300\211\2036\211A\262\242\262
\203+\211G@G\\W\203+\211\301\211A\262\242Q\262
\202\211B\211\262\262\202
\237\207" [nil " "] 8 (#$ . 32882)])
#@179 Remove maximum common indentation in string CODE and return it.
N may optionally be the number of columns to remove.  Return CODE
as-is if removal failed.

(fn CODE &optional N)
(defalias 'org-remove-indentation #[513 "\300\301!r\211q\210\302\303\304\305\306!\307\"\310$\216c\210\311!\203!\312 \202\"*\207" [generate-new-buffer " *temp*" make-byte-code 0 "\301\300!\205	\302\300!\207" vconcat vector [buffer-name kill-buffer] 2 org-do-remove-indentation buffer-string] 9 (#$ . 33171)])
#@74 Find each %key of ALIST in TEMPLATE and replace it.

(fn TEMPLATE ALIST)
(defalias 'org-fill-template #[514 "\301\302\303!\304\"\211\203)\211@\305\306\307@!PA\206\310\311\211%\262
A\266\202\202\210
)\207" [case-fold-search nil sort copy-sequence #[514 "
@G
@GW\207" [] 4 "\n\n(fn A B)"] replace-regexp-in-string "%" regexp-quote "" t] 10 (#$ . 33670)])
#@366 Replace %-escapes in STRING with values in TABLE.
TABLE is an association list with keys like "%a" and string values.
The sequences in STRING may contain normal field width and padding information,
for example "%-5s".  Replacements happen in the sequence given by TABLE,
so values can contain further %-escapes if they are define later in TABLE.

(fn STRING TABLE)
(defalias 'org-replace-escapes #[514 "\301
!\302\303\302\211\211\203p\211@\304\305@\306\"P\262\211A\203D\307A\"\203D\305
A\303\224\303\225#\310\311\303\312\313D$\210\314\315\211A$\241\266\307\n\"\203i\316\305\317\303\f\"\303\320#\321PA\"\262\314\315\211\f$\262	\202D
A\266\202\202\n\210\322\"\211\262\203\235\323\313	#\211\203\231\307\310	#\203\231\314
\315\211$\262\210\202q)\207" [case-fold-search copy-alist nil 0 "%-?[0-9.]*" substring 1 string-match "SREF" add-text-properties 3 sref replace-match t format match-string -1 "s" next-property-change get-text-property] 17 (#$ . 34042)])
#@66 Properties to remove when a string without properties is wanted.
(defconst org-rm-props '(invisible t face t keymap t intangible t mouse-face t rear-nonsticky t mouse-map t fontified t org-emphasis t) (#$ . 35048))
#@153 Remove all text properties from string S.
When RESTRICTED is non-nil, only remove the properties listed
in `org-rm-props'.

(fn S &optional RESTRICTED)
(defalias 'org-no-properties #[513 "\211\203\301\302G$\210\202\303\302G\304$\210
\207" [org-rm-props remove-text-properties 0 set-text-properties nil] 7 (#$ . 35270)])
(put 'org-no-properties 'byte-optimizer 'byte-compile-inline-expand)
#@239 Add text properties to entire string, from beginning to end.
PLIST may be a list of properties, PROPS are individual properties and values
that will be added to PLIST.  Returns the string that was modified.

(fn STRING PLIST &rest PROPS)
(defalias 'org-add-props #[642 "\300\301G\203\302\"\202$\210\207" [add-text-properties 0 append] 9 (#$ . 35675)])
(byte-code "\300\301\302\303#\300\207" [function-put org-add-props lisp-indent-function 2] 4)
#@186 Return alist based on FLAT.
FLAT is a list with alternating symbol names and values.  The
returned alist is a list of lists with the symbol name in car and
the value in cdr.

(fn FLAT)
(defalias 'org-make-parameter-alist #[257 "\211\205\211@
A@D\300AA!B\207" [org-make-parameter-alist] 4 (#$ . 36140)])
#@69 Get text property PROPERTY at the beginning of line.

(fn PROPERTY)
(defalias 'org-get-at-bol #[257 "\300\301 \"\207" [get-text-property point-at-bol] 4 (#$ . 36452)])
(put 'org-get-at-bol 'byte-optimizer 'byte-compile-inline-expand)
#@83 Get text property PROPERTY at the end of line less N characters.

(fn PROPERTY N)
(defalias 'org-get-at-eol #[514 "\300\301 Z\"\207" [get-text-property point-at-eol] 5 (#$ . 36693)])
#@75 Return the first non-nil value of property PROP in string S.

(fn PROP S)
(defalias 'org-find-text-property-in-string #[514 "\300\301#\206\300\302\301#\206\301#\207" [get-text-property 0 next-single-property-change] 7 (#$ . 36884)])
#@285 Non-nil if the character after POS is invisible.
If POS is nil, use `point' instead.  When optional argument
FOLDING-ONLY is non-nil, only consider invisible parts due to
folding of a headline, a block or a drawer, i.e., not because of
fontification.

(fn &optional POS FOLDING-ONLY)
(defalias 'org-invisible-p #[512 "\300\206`\301\"\211\204\302\202
\203\211\303>\202\211\207" [get-char-property invisible nil (org-hide-block outline)] 5 (#$ . 37134)])
#@139 Check if point is at a character currently not visible.
This version does not only check the character property, but also
`visible-mode'.
(defalias 'org-truely-invisible-p #[0 "\301\300!\205?\205
\302 \207" [visible-mode boundp org-invisible-p] 2 (#$ . 37605)])
#@174 Check if point is at a character currently not visible.
If the point is at EOL (and not at the beginning of a buffer too),
move it back by one char before doing this check.
(defalias 'org-invisible-p2 #[0 "\212l\203\fo\204\f\300u\210\301 )\207" [-1 org-invisible-p] 1 (#$ . 37878)])
#@56 Return closest visible buffer position, or `point-max'
(defalias 'org-find-visible #[0 "\300 \203\n\301`\302\"\207`\207" [org-invisible-p next-single-char-property-change invisible] 3 (#$ . 38169)])
#@58 Return closest invisible buffer position, or `point-max'
(defalias 'org-find-invisible #[0 "\300 \203`\207\301`\302\"\207" [org-invisible-p next-single-char-property-change invisible] 3 (#$ . 38375)])
#@192 Convert S to a floating point time.
If S is already a number, just return it.  If it is a string,
parse it as a time string and apply `float-time' to it.  If S is
nil, just return 0.

(fn S)
(defalias 'org-2ft #[257 "\211\247\203\207\211;\203\3001\301\302\303\304!\"!0\207\210\305\207\305\207" [(error) float-time apply encode-time org-parse-time-string 0] 6 (#$ . 38585)])
#@12 

(fn A B)
(defalias 'org-time= #[514 "\300!\300!
\301V\205\211\301V\205

U\207" [org-2ft 0] 6 (#$ . 38972)])
#@12 

(fn A B)
(defalias 'org-time< #[514 "\300!\300!
\301V\205\211\301V\205

W\207" [org-2ft 0] 6 (#$ . 39094)])
#@12 

(fn A B)
(defalias 'org-time<= #[514 "\300!\300!
\301V\205\211\301V\205

X\207" [org-2ft 0] 6 (#$ . 39216)])
#@12 

(fn A B)
(defalias 'org-time> #[514 "\300!\300!
\301V\205\211\301V\205

V\207" [org-2ft 0] 6 (#$ . 39339)])
#@12 

(fn A B)
(defalias 'org-time>= #[514 "\300!\300!
\301V\205\211\301V\205

Y\207" [org-2ft 0] 6 (#$ . 39461)])
#@12 

(fn A B)
(defalias 'org-time<> #[514 "\300!\300!
\301V\205\211\301V\205

U\207" [org-2ft 0] 6 (#$ . 39584)])
#@405 Parse Org time string S.

If time is not given, defaults to 0:00.  However, with optional
NODEFAULT, hour and minute fields are nil if not given.

Throw an error if S does not contain a valid Org time string.
Note that the first match for YYYY-MM-DD will be used (e.g.,
"-52000-02-03" will be taken as "2000-02-03").

This should be a lot faster than the `parse-time-string'.

(fn S &optional NODEFAULT)
(defalias 'org-parse-time-string #[513 "\301\"\204\f\302\303\"\210\304\305\224\203\306\307\305\"!\202$
\203#\310\202$\304\311\224\2033\306\307\311\"!\202<\203;\310\202<\304\306\307\312\"!\306\307\313\"!\306\307\314	\"!\310\211\211\257	\207" [org-ts-regexp0 string-match error "Not an Org time string: %s" 0 8 string-to-number match-string nil 7 4 3 2] 11 (#$ . 39708)])
#@266 Interpret a time comparison value S as a floating point time.

S can be an Org time stamp, a modifier, e.g., "<+2d>", or the
following special strings: "<now>", "<today>",
"<tomorrow>", and "<yesterday>".

Return 0. if S is not recognized as a valid value.

(fn S)
(defalias 'org-matcher-time #[257 "\301\302\303\304\305\306\307 \233\"\"!\310 \311\312\313\314\315!\316\"\306$\216\317\230\203%\301 \202r\320\230\203/
\202r\321\230\203;\322\\\202r\323\230\203G
\324Z\202r\325\326\"\203d
\327\330\331\"!\332\330\333\"\334\"A_\\\202r\325\"\203q\335!\202r\312)\262
\207" [org-ts-regexp0 float-time apply encode-time append (0 0 0) 3 decode-time match-data make-byte-code 0 "\301\300\302\"\207" vconcat vector [set-match-data evaporate] "<now>" "<today>" "<tomorrow>" 86400.0 "<yesterday>" 86400.0 string-match "\\`<\\([-+][0-9]+\\)\\([hdwmy]\\)>\\'" string-to-number match-string 1 assoc 2 (("d" . 86400.0) ("w" . 604800.0) ("m" . 2678400.0) ("y" . 31557600.0)) org-2ft] 9 (#$ . 40511)])
#@228 Receive KEY and scroll the current window accordingly.
When ADDITIONAL-KEYS is not nil, also include SPC and DEL in the
allowed keys for scrolling, as expected in the export dispatch
window.

(fn KEY &optional ADDITIONAL-KEYS)
(defalias 'org-scroll #[513 "\211\203\300\202	\301
\203\302\202\303\304\305\306\307\310B\311B\257!\207" [(32 22) 22 (127 134217846) 134217846 eval cl-case (14 (if (not (pos-visible-in-window-p (point-max))) (ignore-errors (scroll-up 1)) (message "End of buffer") (sit-for 1))) (16 (if (not (pos-visible-in-window-p (point-min))) (ignore-errors (scroll-down 1)) (message "Beginning of buffer") (sit-for 1))) ((if (not (pos-visible-in-window-p (point-max))) (scroll-up nil) (message "End of buffer") (sit-for 1))) ((if (not (pos-visible-in-window-p (point-min))) (scroll-down nil) (message "Beginning of buffer") (sit-for 1)))] 12 (#$ . 41527)])
(provide 'org-macs)