Current File : //usr/local/share/emacs/27.2/lisp/org/org-list.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!\210\300\303!\210\304\305\306\307\310\311\312\313&\210\314\315\316\317\320DD\321\312\305\312\322\323\324& \210\314\325\316\317\326DD\327\312\305\323\330&\210\314\331\316\317\332DD\333\312\305\323\334\335\336& \210\314\337\316\317\340DD\341\312\305\342\343\323\344\335\345& \210\314\346\316\317\347DD\350\312\305\323\351&\210\314\352\316\317\353DD\354\312\305\342\343\323\355& \210\314\356\316\317\357DD\360\312\305\342\343\323\344& \207" [require cl-lib org-macs org-compat custom-declare-group org-plain-lists nil "Options concerning plain lists in Org mode." :tag "Org Plain lists" :group org-structure custom-declare-variable org-cycle-include-plain-lists funcall function #[0 "\300\207" [t] 1] "When t, make TAB cycle visibility on plain list items.\nCycling plain lists works only when the cursor is on a plain list\nitem. When the cursor is on an outline heading, plain lists are\ntreated as text. This is the most stable way of handling this,\nwhich is why it is the default.\n\nWhen this is the symbol `integrate', then integrate plain list\nitems when cycling, as if they were children of outline headings.\n\nThis setting can lead to strange effects when switching visibility\nto `children', because the first \"child\" in a subtree decides\nwhat children should be listed. If that first \"child\" is a\nplain list item with an implied large level number, all true\nchildren and grand children of the outline heading will be\nexposed in a children' view." org-cycle :type (choice (const :tag "Never" nil) (const :tag "With cursor in plain list (recommended)" t) (const :tag "As children of outline headings" integrate)) org-list-demote-modify-bullet #[0 "\300\207" [nil] 1] "Default bullet type installed when demoting an item.\nThis is an association list, for each bullet type, this alist will point\nto the bullet that should be used when this item is demoted.\nFor example,\n\n (setq org-list-demote-modify-bullet\n \\='((\"+\" . \"-\") (\"-\" . \"+\") (\"*\" . \"+\")))\n\nwill make\n\n + Movies\n + Silence of the Lambs\n + My Cousin Vinny\n + Books\n + The Hunt for Red October\n + The Road to Omaha\n\ninto\n\n + Movies\n - Silence of the Lambs\n - My Cousin Vinny\n + Books\n - The Hunt for Red October\n - The Road to Omaha" (repeat (cons (choice :tag "If the current bullet is " (const "-") (const "+") (const "*") (const "1.") (const "1)")) (choice :tag "demotion will change it to" (const "-") (const "+") (const "*") (const "1.") (const "1)")))) org-plain-list-ordered-item-terminator #[0 "\300\207" [t] 1] "The character that makes a line with leading number an ordered list item.\nValid values are ?. and ?\\). To get both terminators, use t.\n\nThis variable needs to be set before org.el is loaded. If you\nneed to make a change while Emacs is running, use the customize\ninterface or run the following code after updating it:\n\n `\\[org-element-update-syntax]'" (choice (const :tag "dot like in \"2.\"" 46) (const :tag "paren like in \"2)\"" 41) (const :tag "both" t)) :set #[514 "L\210\300\301!\205\f \302 \207" [featurep org-element org-element-update-syntax] 4 "\n\n(fn VAR VAL)"] org-list-allow-alphabetical #[0 "\300\207" [nil] 1] "Non-nil means single character alphabetical bullets are allowed.\n\nBoth uppercase and lowercase are handled. Lists with more than\n26 items will fallback to standard numbering. Alphabetical\ncounters like \"[@c]\" will be recognized.\n\nThis variable needs to be set before org.el is loaded. If you\nneed to make a change while Emacs is running, use the customize\ninterface or run the following code after updating it:\n\n `\\[org-element-update-syntax]'" :version "24.1" boolean #[514 "L\210\300\301!\205\f \302 \207" [featurep org-element org-element-update-syntax] 4 "\n\n(fn VAR VAL)"] org-list-two-spaces-after-bullet-regexp #[0 "\300\207" [nil] 1] "A regular expression matching bullets that should have 2 spaces after them.\nWhen nil, no bullet will have two spaces after them. When\na string, it will be used as a regular expression. When the\nbullet type of a list is changed, the new bullet type will be\nmatched against this regexp. If it matches, there will be two\nspaces instead of one after the bullet in each item of the list." (choice (const :tag "never" nil) (regexp)) org-list-automatic-rules #[0 "\300\207" [((checkbox . t) (indent . t))] 1] "Non-nil means apply set of rules when acting on lists.\n\\<org-mode-map>\nBy default, automatic actions are taken when using\n `\\[org-meta-return]',\n `\\[org-metaright]',\n `\\[org-metaleft]',\n `\\[org-shiftmetaright]',\n `\\[org-shiftmetaleft]',\n `\\[org-ctrl-c-minus]',\n `\\[org-toggle-checkbox]',\n `\\[org-insert-todo-heading]'.\n\nYou can disable individually these rules by setting them to nil.\nValid rules are:\n\ncheckbox when non-nil, checkbox statistics is updated each time\n you either insert a new checkbox or toggle a checkbox.\nindent when non-nil, indenting or outdenting list top-item\n with its subtree will move the whole list and\n outdenting a list whose bullet is * to column 0 will\n change that bullet to \"-\"." (alist :tag "Sets of rules" :key-type (choice (const :tag "Checkbox" checkbox) (const :tag "Indent" indent)) :value-type (boolean :tag "Activate" :value t)) org-list-use-circular-motion #[0 "\300\207" [nil] 1] "Non-nil means commands implying motion in lists should be cyclic.\n\\<org-mode-map>\nIn that case, the item following the last item is the first one,\nand the item preceding the first item is the last one.\n\nThis affects the behavior of\n `\\[org-move-item-up]',\n `\\[org-move-item-down]',\n `\\[org-next-item]',\n `\\[org-previous-item]'."] 12)
#@246 Hook that is run whenever Org thinks checkbox statistics should be updated.
This hook runs even if checkbox rule in
`org-list-automatic-rules' does not apply, so it can be used to
implement alternative ways of collecting statistics
information.
(defvar org-checkbox-statistics-hook nil (#$ . 6184))
(byte-code "\300\301\302\303\304DD\305\306\307\310\311&\210\300\312\302\303\313DD\314\306\307\315\316\310\317& \207" [custom-declare-variable org-checkbox-hierarchical-statistics funcall function #[0 "\300\207" [t] 1] "Non-nil means checkbox statistics counts only the state of direct children.\nWhen nil, all boxes below the cookie are counted.\nThis can be set to nil on a per-node basis using a COOKIE_DATA property\nwith the word \"recursive\" in the value." :group org-plain-lists :type boolean org-list-indent-offset #[0 "\300\207" [0] 1] "Additional indentation for sub-items in a list.\nBy setting this to a small number, usually 1 or 2, one can more\nclearly distinguish sub-items in a list." :version "24.1" integer] 10)
#@75 Names of blocks where lists are not allowed.
Names must be in lower case.
(defvar org-list-forbidden-blocks '("example" "verse" "src" "export") (#$ . 7221))
#@41 Regex matching the end of a plain list.
(defconst org-list-end-re "^[ ]*\n[ ]*\n" (#$ . 7384))
#@130 Matches a list item and puts everything into groups:
group 1: bullet
group 2: counter
group 3: checkbox
group 4: description tag
(defconst org-list-full-item-re "^[ ]*\\(\\(?:[-+*]\\|\\(?:[0-9]+\\|[A-Za-z]\\)[.)]\\)\\(?:[ ]+\\|$\\)\\)\\(?:\\[@\\(?:start:\\)?\\([0-9]+\\|[A-Za-z]\\)\\][ ]*\\)?\\(?:\\(\\[[ X-]\\]\\)\\(?:[ ]+\\|$\\)\\)?\\(?:\\(.*\\)[ ]+::\\(?:[ ]+\\|$\\)\\)?" (#$ . 7488))
#@56 Return the correct regular expression for plain lists.
(defalias 'org-item-re #[0 "\302=\203\n \303\202 \304U\203 \305\202 \306U\203 \307\202 \303 \203' \310\202( \311\312\313\314\260\207" [org-plain-list-ordered-item-terminator org-list-allow-alphabetical t "[.)]" 41 ")" 46 "\\." "\\|[A-Za-z]" "" "\\([ ]*\\([-+]\\|\\(\\([0-9]+" "\\)" "\\)\\)\\|[ ]+\\*\\)\\([ ]+\\|$\\)"] 7 (#$ . 7888)])
#@53 Regexp matching the beginning of a plain list item.
(defalias 'org-item-beginning-re #[0 "\300\301 P\207" ["^" org-item-re] 2 (#$ . 8298)])
(put 'org-item-beginning-re 'byte-optimizer 'byte-compile-inline-expand)
#@64 Is point at a list item with REGEXP after bullet?
(fn REGEXP)
(defalias 'org-list-at-regexp-after-bullet-p #[257 "\301 \205% \212\302\225b\210\303\203 \304\202 \305\306Q\307!\203 \302\225b\210\210\307!)\207" [org-list-allow-alphabetical org-at-item-p 0 "\\(?:\\[@\\(?:start:\\)?" "\\([0-9]+\\|[A-Za-z]\\)" "[0-9]+" "\\][ ]*\\)" looking-at] 4 (#$ . 8517)])
#@48 Is point in a context where lists are allowed?
(defalias 'org-list-in-valid-context-p #[0 "\301!?\207" [org-list-forbidden-blocks org-in-block-p] 2 (#$ . 8887)])
#@69 Return item beginning position when in a plain list, nil otherwise.
(defalias 'org-in-item-p #[0 "\212\303 \210\304\305 \211@\306\307!\205 \310 \311 \312\313!\204$ \203( \312!\203( \314\202* \315 \3168\317=\2036 \320\202\312!\203@ `\202\321\322\320\323\324 T#\211\262\203V T\262\202C \325 \"\211\262\203u `@Y\203u `AW\203u \211@b\210\322y\210\266\3262\315 \312!\203\221 \211W\203\221 \327\326`\"\210\202`X\203\237 \327\326\320\"\210\202\312 !\203\255 \327\326\320\"\210\202\312\330!\203\274 \331\332\304#\204\312\333!\203\321 \331\n\304#\203\321 \303 \210\202\203\344 \312!\203\344 \334 \210\322y\210\202\312\313!\203\360 \322y\210\202\211\321U\203\376 \327\326\320\"\210\202\211W\203
\211\262\322y\210\202\322y\210\210\202{ )\266\205)\207" [case-fold-search org-list-end-re org-drawer-regexp beginning-of-line t org-list-context featurep org-inlinetask org-inlinetask-outline-regexp org-item-re looking-at "^[ ]*$" 10000 current-indentation 2 invalid nil 0 -1 string-match "[
\n]" org-in-regexp exit throw "^[ ]*#\\+end_" re-search-backward "^[ ]*#\\+begin_" "^[ ]*:END:" org-inlinetask-goto-beginning] 12 (#$ . 9056)])
#@52 Is point in a line starting a hand-formatted item?
(defalias 'org-at-item-p #[0 "\212\300 \210\301\302 !\205
\303 )\207" [beginning-of-line looking-at org-item-re org-list-in-valid-context-p] 2 (#$ . 10238)])
#@46 Is point at the bullet of a plain list item?
(defalias 'org-at-item-bullet-p #[0 "\300 \205 \301f\302\235?\205 `\303\225W\207" [org-at-item-p nil (32 9) 0] 2 (#$ . 10454)])
#@61 Is point at a line starting a plain list item with a timer?
(defalias 'org-at-item-timer-p #[0 "\300\301!\207" [org-list-at-regexp-after-bullet-p "\\([0-9]+:[0-9]+:[0-9]+\\)[ ]+::[ ]+"] 2 (#$ . 10635)])
#@38 Is point at a description list item?
(defalias 'org-at-item-description-p #[0 "\300\301!\207" [org-list-at-regexp-after-bullet-p "\\(\\S-.+\\)[ ]+::\\([ ]+\\|$\\)"] 2 (#$ . 10846)])
#@64 Is point at a line starting a plain-list item with a checklet?
(defalias 'org-at-item-checkbox-p #[0 "\300\301!\207" [org-list-at-regexp-after-bullet-p "\\(\\[[- X]\\]\\)[ ]+"] 2 (#$ . 11036)])
#@63 Is point at a line starting a plain-list item with a counter?
(defalias 'org-at-item-counter-p #[0 "\301 \205 \302!\205 \303\304!\207" [org-list-full-item-re org-at-item-p looking-at match-string 2] 2 (#$ . 11237)])
#@286 Determine context, and its boundaries, around point.
Context will be a cell like (MIN MAX CONTEXT) where MIN and MAX
are boundaries and CONTEXT is a symbol among `drawer', `block',
`invalid', `inlinetask' and nil.
Contexts `block' and `invalid' refer to `org-list-forbidden-blocks'.
(defalias 'org-list-context #[0 "\306 \307\310\311\312\313!\314\"\315$\216\212\316\317 \211\320 P\321 \210\316`\322\211\211\212\3231. \324\316!0\2023 \210\322\2027 \2057 `)\206< e\212\325 )\206D d \326
\212\327!?\205\202 \327!?\205\202 \330\316#\205c \331 T\211\262\205\202 \332\316#\203w \310\224S\206x \211\262\205\202 Y)\203\220 \262\262\333\262\266\334\322\212\327!?\205\345 \330\316#\205\247 \331 T\211\262\205\345 \327\335!\205\345 \336\337!\227\211\262\205\345 b\205\345 \332\316#\203\321 \340 S\206\322 \211\262\205\345 Y\205\345 \336\337!\227\341\232)\203\376 \262\262\211*\235\203\373 \342\202\374 \343\262\266\344\345!\203O\212\346 \211\347P\327\350!?\205@\330\316#\205 \331 T\211\262\205@\327!?\205@\332\316#\2056\310\224S\211\262\205@`V\266\202)\203O\262\262\351\262E)\266\207.\207" [org-called-with-limited-levels org-outline-regexp outline-regexp org-outline-regexp-bol case-fold-search org-drawer-regexp match-data make-byte-code 0 "\301\300\302\"\207" vconcat vector [set-match-data evaporate] 3 t org-get-limited-outline-regexp "^" beginning-of-line nil (error) org-back-to-heading outline-next-heading "^[ ]*:END:" looking-at re-search-backward point-at-eol re-search-forward drawer "^[ ]*#\\+\\(begin\\|end\\)_" "^[ ]*#\\+begin_\\(\\S-+\\)" match-string 1 point-at-bol "end" invalid block featurep org-inlinetask org-inlinetask-outline-regexp "END[ ]*$" "^\\*+" inlinetask org-list-forbidden-blocks] 15 (#$ . 11463)])
#@905 Return structure of list at point.
A list structure is an alist where key is point at item, and
values are:
1. indentation,
2. bullet with trailing whitespace,
3. bullet counter, if any,
4. checkbox, if any,
5. description tag, if any,
6. position at item end.
Thus the following list, where numbers in parens are
point-at-bol:
- [X] first item (1)
1. sub-item 1 (18)
5. [@5] sub-item 2 (34)
some other text belonging to first item (55)
- last item (97)
+ tag :: description (109)
(131)
will get the following structure:
((1 0 "- " nil "[X]" nil 97)
(18 2 "1. " nil nil nil 34)
(34 2 "5. " "5" nil nil 55)
(97 0 "- " nil nil nil 131)
(109 2 "+ " nil nil "tag" 131))
Assume point is at an item.
(defalias 'org-list-struct #[0 "\212\303 \210\304\305 \211@A@\306\307 \310\311!\205 \312 `\313 B\314\211\211\211\211\315\316\212\3172\313 `X\203Y \320\317\321
!\204F \n@\n\236\n>\202Q `B\262 !\nB\211\262 \"\210\202\321 !\203r \320\317\n@\n\236\n>\211\262 \"\210\202\321 !\203\233 !B\262\211`BB\262\211\fW\203\225 `B\262 \322y\210\202\321\323!\203\252 \324\325\304#\204\321\326!\203\277 \324\n\304#\203\277 \303 \210\202 \203\324 \321\n!\203\324 \327 \210\322y\210\202\321\330!\203\340 \322y\210\202\211\331U\203\371 \320\317\n@\n\236\n>\211\262 \"\210\202\211\fW\203\211\262\f\211`BB\262\322y\210\210\202( \210)\3172\323\313 `
Y\2034\320\317\331!BB\211\262\"\210\202\317\321 !\203J\320\317\331`BB\211\262\"\210\202\317\321 !\203f!B\262\211`BB\262\332y\210\202\317 \203x\321\n!\203x\333 \210\202\317\321\330!\203\204\332y\210\202\317\211 AX\203\237\320\317\331!BB\211\262\"\210\202\317\211@A@X\203\260\211`BB\262\321\325!\203\277\334\323\304#\204\314\321\n!\203\314\334\326\304#\210\332y\210\210\202\210\335\237A\"\262\335\237A\"\262\336\"\210)\266\216)\207" [case-fold-search org-list-end-re org-drawer-regexp beginning-of-line t org-list-context 10000 org-item-re featurep org-inlinetask org-inlinetask-outline-regexp current-indentation nil #[257 "\302!\210\303\304!`\303\305!\303\306!\307\310\311\312#)\266\203\205$ \303\313!\257\207" [org-list-full-item-re inhibit-changing-match-data looking-at match-string-no-properties 1 2 3 "[-+*]" nil t string-match 4] 14 "\n\n(fn IND)"] #[257 "\300\301x\210\302 T^\207" ["
\n" nil point-at-eol] 3 "\n\n(fn LIM-DOWN)"] exit throw looking-at -1 "^[ ]*#\\+end_" re-search-backward "^[ ]*#\\+begin_" "^[ ]*:END:" org-inlinetask-goto-beginning "^[ ]*$" 0 1 org-inlinetask-goto-end re-search-forward append org-list-struct-assoc-end] 20 (#$ . 13271)])
#@186 Associate proper ending point to items in STRUCT.
END-LIST is a pseudo-alist where car is indentation and cdr is
ending position.
This function modifies STRUCT.
(fn STRUCT END-LIST)
(defalias 'org-list-struct-assoc-end #[514 "\211C\300\301\302\303\304\305!\306\"\307\310%\"\207" [mapc make-byte-code 257 "\211@A@\300\242@AX\203 \300\242\300\211\242A\240\266\202 \301\233\302\300\242\303#\203- \240\2026 \304AC\"\241\266\202\207" vconcat vector [6 assoc-default <= append] 9 "\n\n(fn ELT)"] 10 (#$ . 16117)])
#@69 Return alist between item and previous item in STRUCT.
(fn STRUCT)
(defalias 'org-list-prevs-alist #[257 "\300\301\"\300\302\303\304\305\306!\307\"\310\311%\"\207" [mapcar #[257 "\211@\3008B\207" [6] 4 "\n\n(fn E)"] make-byte-code 257 "\301@\300\"@@B\207" vconcat vector [rassq] 4 "\n\n(fn E)"] 9 (#$ . 16651)])
#@62 Return alist between item and parent in STRUCT.
(fn STRUCT)
(defalias 'org-list-parents-alist #[257 "\211@A@CCC\300!\211CC\211\242\301\302\303\304\305\306 \"\307\"\310\311%A\"B\207" [org-list-get-top-point mapcar make-byte-code 257 "\211@A@\300\242@@\301\301\242B\240\210\211V\203G \300\300\242\236\300\242\235\206< \3022< \303\304\305\306\307\310\300 \"\311\"\312\313%\300\242\"\210CC0\240\210\300\242@AB\202h \211W\203b \301\242A@\300B\300\242B\240\210B\262\202h \300\242@AB\207" vconcat vector [exit mapc make-byte-code 257 "\211@\301W\205 \302\303\300\242\235\"\207" vconcat vector [throw exit] 5 "\n\n(fn E)"] 13 "\n\n(fn ITEM)"] 13 (#$ . 16978)])
#@108 Delete metadata from the heading at point.
Metadata are tags, planning information and properties drawers.
(defalias 'org-list--delete-metadata #[0 "\300 \301\302\303\304\305!\306\"\307$\216\212\214~\210\310\311!\210\312\313!\212\314 \210\315 \210m\203( `\202* \312 )|+\207" [match-data make-byte-code 0 "\301\300\302\"\207" vconcat vector [set-match-data evaporate] 3 org-set-tags nil line-beginning-position 2 org-end-of-meta-data org-skip-whitespace] 7 (#$ . 17661)])
#@59 Return the Nth value of KEY in STRUCT.
(fn N KEY STRUCT)
(defalias 'org-list-get-nth #[771 "\2368\207" [] 6 (#$ . 18139)])
(put 'org-list-get-nth 'byte-optimizer 'byte-compile-inline-expand)
#@99 Set the Nth value of KEY in STRUCT to NEW.
This function modifies STRUCT.
(fn N KEY STRUCT NEW)
(defalias 'org-list-set-nth #[1028 "\236\233\240\207" [] 7 (#$ . 18340)])
#@57 Return indentation of ITEM in STRUCT.
(fn ITEM STRUCT)
(defalias 'org-list-get-ind #[514 "\300\2368\207" [1] 8 (#$ . 18522)])
(put 'org-list-get-ind 'byte-optimizer 'byte-compile-inline-expand)
#@97 Set indentation of ITEM in STRUCT to IND.
This function modifies STRUCT.
(fn ITEM STRUCT IND)
(defalias 'org-list-set-ind #[771 "\300\301$\207" [org-list-set-nth 1] 8 (#$ . 18728)])
#@52 Return bullet of ITEM in STRUCT.
(fn ITEM STRUCT)
(defalias 'org-list-get-bullet #[514 "\300\2368\207" [2] 8 (#$ . 18921)])
(put 'org-list-get-bullet 'byte-optimizer 'byte-compile-inline-expand)
#@98 Set bullet of ITEM in STRUCT to BULLET.
This function modifies STRUCT.
(fn ITEM STRUCT BULLET)
(defalias 'org-list-set-bullet #[771 "\300\301$\207" [org-list-set-nth 2] 8 (#$ . 19128)])
#@53 Return counter of ITEM in STRUCT.
(fn ITEM STRUCT)
(defalias 'org-list-get-counter #[514 "\300\2368\207" [3] 8 (#$ . 19325)])
(put 'org-list-get-counter 'byte-optimizer 'byte-compile-inline-expand)
#@61 Return checkbox of ITEM in STRUCT or nil.
(fn ITEM STRUCT)
(defalias 'org-list-get-checkbox #[514 "\300\2368\207" [4] 8 (#$ . 19535)])
(put 'org-list-get-checkbox 'byte-optimizer 'byte-compile-inline-expand)
#@104 Set checkbox of ITEM in STRUCT to CHECKBOX.
This function modifies STRUCT.
(fn ITEM STRUCT CHECKBOX)
(defalias 'org-list-set-checkbox #[771 "\300\301$\207" [org-list-set-nth 4] 8 (#$ . 19756)])
#@58 Return end position of ITEM in STRUCT.
(fn ITEM STRUCT)
(defalias 'org-list-get-tag #[514 "\300\2368\207" [5] 8 (#$ . 19961)])
(put 'org-list-get-tag 'byte-optimizer 'byte-compile-inline-expand)
#@58 Return end position of ITEM in STRUCT.
(fn ITEM STRUCT)
(defalias 'org-list-get-item-end #[514 "\300\2368\207" [6] 8 (#$ . 20168)])
#@115 Return point at end of ITEM in STRUCT, before any blank line.
Point returned is at end of line.
(fn ITEM STRUCT)
(defalias 'org-list-get-item-end-before-blank #[514 "\212\300\"b\210\301\302x\210\303 )\207" [org-list-get-item-end "
\n" nil point-at-eol] 5 (#$ . 20313)])
#@162 Return parent of ITEM or nil.
STRUCT is the list structure. PARENTS is the alist of parents,
as returned by `org-list-parents-alist'.
(fn ITEM STRUCT PARENTS)
(defalias 'org-list-get-parent #[771 "\211\206 \300!\236A\207" [org-list-parents-alist] 6 (#$ . 20595)])
#@139 Non-nil if ITEM has a child.
STRUCT is the list structure.
Value returned is the position of the first child of ITEM.
(fn ITEM STRUCT)
(defalias 'org-list-has-child-p #[514 "\300\2368\266\205\236\235A@@\211\205* \300\2368\266\205W\205* \211\207" [1] 13 (#$ . 20872)])
#@184 Return next item in same sub-list as ITEM, or nil.
STRUCT is the list structure. PREVS is the alist of previous
items, as returned by `org-list-prevs-alist'.
(fn ITEM STRUCT PREVS)
(defalias 'org-list-get-next-item #[771 "\300\"@\207" [rassq] 6 (#$ . 21168)])
#@188 Return previous item in same sub-list as ITEM, or nil.
STRUCT is the list structure. PREVS is the alist of previous
items, as returned by `org-list-prevs-alist'.
(fn ITEM STRUCT PREVS)
(defalias 'org-list-get-prev-item #[771 "\236A\207" [] 5 (#$ . 21439)])
#@106 List all items having ITEM as a common ancestor, or nil.
STRUCT is the list structure.
(fn ITEM STRUCT)
(defalias 'org-list-get-subtree #[514 "\300\"\236\235A\301\30229 \211\2056 \211@\211@\211\211W\203( \211B\262\202- \303\302\301\"\210\266A\266\202\202 \2620\210\211\237\207" [org-list-get-item-end nil :exit throw] 12 (#$ . 21707)])
#@178 List all items in the same sub-list as ITEM.
STRUCT is the list structure. PREVS is the alist of previous
items, as returned by `org-list-prevs-alist'.
(fn ITEM STRUCT PREVS)
(defalias 'org-list-get-all-items #[771 "\211\300\211\301#\211\262\203 B\262\202 \302#\211\262\203. B\262\202 \303C\237#\207" [nil org-list-get-prev-item org-list-get-next-item append] 11 (#$ . 22065)])
#@167 List all children of ITEM, or nil.
STRUCT is the list structure. PARENTS is the alist of parents,
as returned by `org-list-parents-alist'.
(fn ITEM STRUCT PARENTS)
(defalias 'org-list-get-children #[771 "\300\211\301\"@\211\262\203 \211\236\235A\262\211B\262\202 \237\207" [nil rassq] 8 (#$ . 22478)])
#@79 Return point at beginning of list.
STRUCT is the list structure.
(fn STRUCT)
(defalias 'org-list-get-top-point #[257 "\211@@\207" [] 2 (#$ . 22799)])
#@76 Return point at bottom of list.
STRUCT is the list structure.
(fn STRUCT)
(defalias 'org-list-get-bottom-point #[257 "\300\301\302\303\304\305\306\307!\310\"\311\312%\"\"\207" [apply max mapcar make-byte-code 257 "\301@\300\"\207" vconcat vector [org-list-get-item-end] 4 "\n\n(fn E)"] 10 (#$ . 22956)])
#@185 Return point at beginning of sub-list ITEM belongs.
STRUCT is the list structure. PREVS is the alist of previous
items, as returned by `org-list-prevs-alist'.
(fn ITEM STRUCT PREVS)
(defalias 'org-list-get-list-begin #[771 "\300\301#\211\262\203 \211\262\202 \207" [nil org-list-get-prev-item] 9 (#$ . 23272)])
(defalias 'org-list-get-first-item 'org-list-get-list-begin)
#@185 Return point at last item of sub-list ITEM belongs.
STRUCT is the list structure. PREVS is the alist of previous
items, as returned by `org-list-prevs-alist'.
(fn ITEM STRUCT PREVS)
(defalias 'org-list-get-last-item #[771 "\300\301#\211\262\203 \211\262\202 \207" [nil org-list-get-next-item] 9 (#$ . 23662)])
#@179 Return point at end of sub-list ITEM belongs.
STRUCT is the list structure. PREVS is the alist of previous
items, as returned by `org-list-prevs-alist'.
(fn ITEM STRUCT PREVS)
(defalias 'org-list-get-list-end #[771 "\300\301#\"\207" [org-list-get-item-end org-list-get-last-item] 8 (#$ . 23990)])
#@309 Return the type of the list containing ITEM, as a symbol.
STRUCT is the list structure. PREVS is the alist of previous
items, as returned by `org-list-prevs-alist'.
Possible types are `descriptive', `ordered' and `unordered'. The
type is determined by the first item of the list.
(fn ITEM STRUCT PREVS)
(defalias 'org-list-get-list-type #[771 "\301#\302\303\2368\266\205\304\305\306#)\266\203\203$ \307\2028 \211\310\2368\266\205\2037 \311\2028 \312\207" [inhibit-changing-match-data org-list-get-list-begin "[[:alnum:]]" 2 nil t string-match ordered 5 descriptive unordered] 13 (#$ . 24300)])
#@327 Return ITEM's sequence number.
STRUCT is the list structure. PREVS is the alist of previous
items, as returned by `org-list-prevs-alist'. PARENTS is the
alist of ancestors, as returned by `org-list-parents-alist'.
Return value is a list of integers. Counters have an impact on
that value.
(fn ITEM STRUCT PREVS PARENTS)
(defalias 'org-list-get-item-number #[1028 "\300\211#C\301#\211\262\203# #B\262\202 \266\202\207" [#[771 "\300\301\302\2368\266\205\211\262\204) \303#\211\262\203) T\262\202 \211\2042 T\202[ \304\305\"\203G \306\307\300\"\226!\310Z\\\202[ \304\311\"\203Y \312\307\300\"!\\\202[ T\207" [0 nil 3 org-list-get-prev-item string-match "[A-Za-z]" string-to-char match-string 64 "[0-9]+" string-to-number] 14 "\n\n(fn ITEM STRUCT PREVS)"] org-list-get-parent] 11 (#$ . 24926)])
#@162 Search a string in valid contexts for lists.
Arguments SEARCH, RE, BOUND and NOERR are similar to those used
in `re-search-forward'.
(fn SEARCH RE BOUND NOERR)
(defalias 'org-list-search-generic #[1028 "\3002, `#\204 \301\300\302>\203 \202 b\210\303\"\210\304 \203 \301\300`\"\210\202 \207" [exit throw (t nil) nil org-list-in-valid-context-p] 9 (#$ . 25776)])
#@193 Like `re-search-backward' but stop only where lists are recognized.
Arguments REGEXP, BOUND and NOERROR are similar to those used in
`re-search-backward'.
(fn REGEXP &optional BOUND NOERROR)
(defalias 'org-list-search-backward #[769 "\300\301\206 e$\207" [org-list-search-generic re-search-backward] 8 (#$ . 26157)])
#@191 Like `re-search-forward' but stop only where lists are recognized.
Arguments REGEXP, BOUND and NOERROR are similar to those used in
`re-search-forward'.
(fn REGEXP &optional BOUND NOERROR)
(defalias 'org-list-search-forward #[769 "\300\301\206 d$\207" [org-list-search-generic re-search-forward] 8 (#$ . 26486)])
#@175 Return BULLET with the correct number of whitespaces.
It determines the number of whitespaces to append by looking at
`org-list-two-spaces-after-bullet-regexp'.
(fn BULLET)
(defalias 'org-list-bullet-string #[257 "\301 \302\303\304\305\306!\307\"\310$\216\203 \311\"\203 \312\202 \313\311\314\"\2030 \315\316\211\317%\2021 \262)\207" [org-list-two-spaces-after-bullet-regexp match-data make-byte-code 0 "\301\300\302\"\207" vconcat vector [set-match-data evaporate] 3 string-match " " " " "\\S-+\\([ ]*\\)" replace-match nil 1] 9 (#$ . 26811)])
(put 'org-list-bullet-string 'byte-optimizer 'byte-compile-inline-expand)
#@342 Swap item starting at BEG-A with item starting at BEG-B in STRUCT.
Blank lines at the end of items are left in place. Item
visibility is preserved. Return the new structure after the
changes.
Assume BEG-A is lesser than BEG-B and that BEG-A and BEG-B belong
to the same sub-list.
This function modifies STRUCT.
(fn BEG-A BEG-B STRUCT)
(defalias 'org-list-swap-items #[771 "\212\300\"\300\"\301\"\301\"ZZ{{\n{ \302
\f\"B \302
\"B\303\304\305\306\307\310\311\312\"\313\"\314\315%\316\"\"\"\303\304\305\306\307\310\311\312\"\317\"\314\315%\316\"\"\"Bb\210 |\210Qc\210\f\211\203&\211@\211@\211W\204 \211>\203\303 \3208Z\\\240\210\320\233Z\\\240\210\211U\203\277 \320\233
\240\210\210\202 \211>\203\375 \3208\\Z\240\210\320\233Z\\\240\210\211
U\203\371 \320\233\321
Z#\240\210\210\202 \211W\203 \3208\fZ\\\240\210\320\233\fZ\\\240\266\210A\266\202\202\202 \210\322
\323\"\262
\211@\211\203`\211@\324@A@\fZ\\Z\\\3258
Z\\Z\\#\210A\266\202\2020\210\211A\211\203\207\211@\324@A@Z\\\3258Z\\#\210A\266\202\202c\210\f\266\214)\207" [org-list-get-item-end-before-blank org-list-get-item-end org-list-get-subtree delq nil mapcar make-byte-code 257 "\302!\300Y\205 \303!\301X\205 \211\302!\303!E\207" vconcat vector [overlay-start overlay-end] 5 "\n\n(fn O)" overlays-in [overlay-start overlay-end] 6 + sort car-less-than-car move-overlay 2] 25 (#$ . 27453)])
#@373 Return number of blank lines that should separate items in list.
POS is the position of point where `org-list-insert-item' was called.
STRUCT is the list structure. PREVS is the alist of previous
items, as returned by `org-list-prevs-alist'.
Assume point is at item's beginning. If the item is alone, apply
some heuristics to guess the result.
(fn POS STRUCT PREVS)
(defalias 'org-list-separating-blank-lines-number #[771 "\212`\301\236A\302\303\204 \304\202x \305=\203 \306\202x \307#\211\203- \211b\210 \202v \310#\203< \202v \311 \"V\203\\ \212b\210 \211\262)\304V\203\\ \202v \212\312!b\210\313\314\311\n\"\305#)\203u \306\202v \304\262\266\204)\207" [org-blank-before-new-entry plain-list-item nil #[0 "\212\300\301 b\302\303x\210\303y\210`\")\207" [count-lines point-at-bol "
\n" nil] 4] 0 t 1 org-list-get-next-item org-list-get-prev-item org-list-get-item-end-before-blank org-list-get-top-point re-search-forward "^[ ]*$"] 13 (#$ . 28975)])
#@510 Insert a new list item at POS and return the new structure.
If POS is before first character after bullet of the item, the
new item will be created before the current one.
STRUCT is the list structure. PREVS is the alist of previous
items, as returned by `org-list-prevs-alist'.
Insert a checkbox if CHECKBOX is non-nil, and string AFTER-BULLET
after the bullet. Cursor will be after this text once the
function ends.
This function modifies STRUCT.
(fn POS STRUCT PREVS &optional CHECKBOX AFTER-BULLET)
(defalias 'org-list-insert-item #[1283 "\306\3072S \310\211\203F \211@\211@A\211A\211A\211A\211A\211A\211@A \211V\2033 \311\307\"\210\202= W\204= \211\262\266 A\266\202\202 \210\211\206P \312!@@\2620\313\"\314\"b\210\315 !\210\316\224\204p \317\225\202\232 \320 \321\317\322\323\324!\325\"\326$\216\327\330\331\332!\")\262\203\217 \316\224\202\232 \212\316\225b\210\333\310w\210`)X\n\334\211\306=\203\247 \306\202\323 \306=\203\261 \306\202\323 \335\"\203\300 \335\"A\202\323 \336\236A\211<\203\320 \337\310\"\202\321 \211\262\266\202\340\n\n\n#\n\332\2368\266\205 \203\371 \211\f\245\341\f\"\\\202\372 \211\f\342\2368\266\205\320 \321\317\322\323\324!\343\"\326$\216
\203%\327
\"\203%\344\202&\345\327\346\"\2038\347\310\211\332%\2029\262)\266\202\n\205D\350?\205s\205sb\210W\203aS\351 |\210\352\310x\210\212\333\310w\210`\262)\353` \"\205{\345P
\205\223\327\354\"\203\222\347\355\306\211$\202\223R\356T\357\"\360GG#\211GZb\210j\210\261\210\211\203O\211@\211@\3618W\203\332\211V\203F\361\233\\\240\210\202FU\203\376\204\376\203\376\\\240\210\361\233\\\240\210\202F\2036\2046Y\2036X\2036\362GG%Z\240\210\361\233Z\240\266\202F\\\240\210\361\233\\\240\210\266A\266\202\202\265\210 \310 \310\\\257B\262\363\364\"\262 \203yb\210\202\220\365\211\\#\262\366\367!#b\210)\207" [case-fold-search org-list-full-item-re org-M-RET-may-split-line indent-tabs-mode tab-width org-list-two-spaces-after-bullet-regexp t :exit nil throw reverse org-list-get-item-end org-list-get-item-end-before-blank looking-at 4 0 match-data make-byte-code "\301\300\302\"\207" vconcat vector [set-match-data evaporate] 3 string-match "[.)]" match-string 1 " " item assoc default delq org-list-separating-blank-lines-number mod 2 [set-match-data evaporate] " " " " "\\S-+\\([ ]*\\)" replace-match "[ ]" point-at-eol "
\n" delete-and-extract-region "\\`[ ]+" "" make-string 10 + 6 - sort car-less-than-car org-list-swap-items org-list-get-next-item org-list-prevs-alist] 30 (#$ . 29975)])
#@106 Remove ITEM from the list and return the new structure.
STRUCT is the list structure.
(fn ITEM STRUCT)
(defalias 'org-list-delete-item #[514 "\300\"\301!U\203 \212b\210\302\303x\210\304 Td^)\202 \211|\210Z\305\303\306\307\310\311\312\313\f $\314\"\315\316%\"\"\262\207" [org-list-get-item-end org-list-get-bottom-point "
\n" nil point-at-eol delq mapcar make-byte-code 257 "\211@\211\300W\2033 \3048\211\300W\203 \202. \211\300U\203% \305\306!\302C\"\202. \305\306!\303ZC\"\262\202M \211\301W\203= \307\202M \211\303Z\305\306A!\3048\303ZC\"B\207" vconcat vector [6 append butlast nil] 7 "\n\n(fn E)"] 17 (#$ . 32681)])
#@731 Send ITEM to destination DEST.
STRUCT is the list structure.
DEST can have various values.
If DEST is a buffer position, the function will assume it points
to another item in the same list as ITEM, and will move the
latter just before the former.
If DEST is `begin' (respectively `end'), ITEM will be moved at
the beginning (respectively end) of the list it belongs to.
If DEST is a string like "N", where N is an integer, ITEM will
be moved at the Nth position in the list.
If DEST is `kill', ITEM will be deleted and its body will be
added to the kill-ring.
If DEST is `delete', ITEM will be deleted.
Visibility of item is preserved.
This function returns, destructively, the new list structure.
(fn ITEM DEST STRUCT)
(defalias 'org-list-send-item #[771 "\211CC\302\242!\303\242\242\"\212\242b\210\304\305\306\242\242\307\2368\266\205!P!\210\310\225){\311\312\2038 \313\2029 \314\315\312\316\315##\266\202\317=\206\326 \320=\206\326 \321\267\202\201 \322\242\242#\211\262\202\326 \323\242\242#\262\212\324\242\242#b\210\325 )\202\326 \326\311\327\330#)\266\203\203\324 \331\242\242#\211G\332\333\n!\"\211\310U\204\263 \211S8\211\262 \202\317 \323\242 \242#\262\n\212\324\242 \242#b\210\325 )\266\203\202\326 \311\334\335\336\337\340\341\n!\342\"\343\344%\345\242\"\"\346\267\202\347\242\242\"\202\307\350!\210\347\242\242\"\202\307\250\203\304\242U\204\304\351\242!\240\210\352 \242\311%\240\210\353\242!\354\353\242! \242\"B\303` \242\"\303\353 \242!\n\242\"``\n\242Z \320\242\236\242\"\240\210 \355\356\242\357\335\336\360\340\341
$\361\"\362\363%\n\"\"\364\"\240\266\211\211\203\257\211@\365\366!` \242Z\\\367!`\f\242Z\\#\210A\266\202\202\214\210\347\353\242!\242\"\242\311\211\223\210\202\307\242)\266\205\207" [inhibit-changing-match-data org-M-RET-may-split-line org-list-prevs-alist org-list-get-item-end looking-at "[ ]*" regexp-quote 2 0 nil replace-regexp-in-string "\\`\\([ ]*\n\\)+" "\\`[ \n
]+" "" "[ \n
]+\\'" kill delete #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (begin 88 end 102)) org-list-get-list-begin org-list-get-list-end org-list-get-last-item point-at-eol "\\`[0-9]+\\'" t string-match org-list-get-all-items mod string-to-number cl-remove-if make-byte-code 257 "\301!\300\242W\206 \302!\300\242V\207" vconcat vector [overlay-start overlay-end] 3 "\n\n(fn O)" overlays-in #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (delete 245 kill 256)) org-list-delete-item kill-new copy-marker org-list-insert-item marker-position org-list-get-subtree sort append mapcar "\211\300\242\236\211@\3048\303\\\305\306A!\302U\203 \301\202 \303\\C\"B\207" [6 append butlast] 9 "\n\n(fn E)" car-less-than-car move-overlay overlay-start overlay-end] 29 (#$ . 33340)])
#@226 Outdent items between positions START and END.
STRUCT is the list structure. PARENTS is the alist of items'
parents, as returned by `org-list-parents-alist'.
START is included, END excluded.
(fn START END STRUCT PARENTS)
(defalias 'org-list-struct-outdent #[1028 "\300C\301\302\303\304\305 %\306\"\307\310%\311\"\207" [nil make-byte-code 257 "\211@A\300W\203 \202] \301Y\203- \211\205 \211\304\242\236\211\203' AB\202( \262\202] \211\2047 \305\306!\202] \211\300Y\203J \304B\304\242B\240\210\202] \307\302\303#\304B\304\242B\240\210B\262\207" vconcat vector [error "Cannot outdent top-level items" org-list-get-parent] 7 "\n\n(fn CELL)" mapcar] 15 (#$ . 36271)])
#@405 Indent items between positions START and END.
STRUCT is the list structure. PARENTS is the alist of parents
and PREVS is the alist of previous items, returned by,
respectively, `org-list-parents-alist' and
`org-list-prevs-alist'.
START is included and END excluded.
STRUCT may be modified if `org-list-demote-modify-bullet' matches
bullets between START and END.
(fn START END STRUCT PARENTS PREVS)
(defalias 'org-list-struct-indent #[1285 "\300C\301\302\303\304\305!\306\"\307\310%\301\302\311\304\305 \n\n\n&\312\"\313\310%\314\"\207" [nil make-byte-code 257 "\300\300\242B\240\210\207" vconcat vector [] 4 "\n\n(fn CELL)" "\211@A\300W\203 \202 \301Y\203) \211\304\242\236\211\203# AB\202$ \262\202 \306\302\303#\307\302\310\2368\266\205\311 ,\312\313\"\203I \314\202\226 \312\315\"\203T \316\202\226 \312\317\"\203_ \320\202\226 \312\321\"\203j \322\202\226 \312\323\"\203u \324\202\226 \312\325\"\203\200 \326\202\226 \211\311\327\203\213 \330\202\214 \331\332\327\333\332##\266\202)\262-\"\211:\203\344 \211A\211\334\302\335 \336\337\340\341\342!\343\"\344$\216.\203\310 \312.\"\203\310 \345\202\311 \346\312\347\"\203\333 \350\311\211\351%\202\334 \262)\266\202#\266\210\211\204\371 \203\363 \300W\203\371 \352\353!\202\211\204\305!\202\211\300W\203\305B!\202\305\304\242\236AB!\262\207" [org-list-get-prev-item assoc 2 nil string-match "[A-Z]\\." "A." "[A-Z])" "A)" "[a-z]\\." "a." "[a-z])" "a)" "[0-9]\\." "1." "[0-9])" "1)" replace-regexp-in-string "\\`\\([ ]*\n\\)+" "\\`[ \n
]+" "" "[ \n
]+\\'" org-list-set-bullet match-data make-byte-code 0 "\301\300\302\"\207" vconcat vector [set-match-data evaporate] 3 " " " " "\\S-+\\([ ]*\\)" replace-match 1 user-error "Cannot indent the first item of a list" case-fold-search org-list-demote-modify-bullet org-list-two-spaces-after-bullet-regexp] 19 mapcar] 18 (#$ . 36975)])
#@196 Non-nil if list starting at FIRST can have alphabetical bullets.
STRUCT is list structure. PREVS is the alist of previous items,
as returned by `org-list-prevs-alist'.
(fn FIRST STRUCT PREVS)
(defalias 'org-list-use-alpha-bul-p #[771 "\205] \3032] \304\305\203X \306\2368\266\205\211\2039 \307\305\310\311#)\266\203\2039 \312\226!\262\202= T\262\313V\203K \314\303\305\"\210\202T \315#\262\210\202\f )\310\266\2020\207" [org-list-allow-alphabetical case-fold-search inhibit-changing-match-data exit 64 nil 3 "[a-zA-Z]" t string-match string-to-char 90 throw org-list-get-next-item] 13 (#$ . 38897)])
#@46 Increment BULLET if applicable.
(fn BULLET)
(defalias 'org-list-inc-bullet-maybe #[257 "\301\302\303\"\203 \304\305\306\307\310\"!T!\301\211$\2023 \302\311\"\2032 \304\312\313\307\310\"!T!\301\211$\2023 \211)\207" [case-fold-search nil string-match "[0-9]+" replace-match number-to-string string-to-number match-string 0 "[A-Za-z]" char-to-string string-to-char] 7 (#$ . 39533)])
#@167 Verify and correct bullets in STRUCT.
PREVS is the alist of previous items, as returned by
`org-list-prevs-alist'.
This function modifies STRUCT.
(fn STRUCT PREVS)
(defalias 'org-list-struct-fix-bul #[514 "\301\302\303\304\305\306\"\307\"\310\311%\312\313\314\"\")\207" [case-fold-search nil make-byte-code 257 "\303\300\301#\211\205 \211\300\304\2368\266\205\300\305\2368\266\205\300\304\2368\266\205?\2057 \306\300\301#\307\300\203w \203w \310\311\"\203w \310\311\"\203w \310\312\"\203a \227\202k \310\313\"\205k \226\314\315\211 $\262\202P\203\233 \203\233 \310\316\"\203\233 \310\316\"\203\233 \314\315\211\n$\202P\203\262 \317\300\304\2368\266\205!\202P\203\362 \306 \300\301#\203\362 \310\320\"\203\362 \310\320\"\203\362 \310\312\"\203\334 \227\202\346 \310\313\"\205\346 \226\314\315\211 $\262\202P\203\310\316\"\203\310\316\"\203\314\315\211$\202P\203'\310\313\"\203'\314\321\315\211$\202P\203=\310\312\"\203=\314\322\315\211$\202P\310\323\"\203O\314\324\315\211$\202P\325 \326\327\330\331\332!\333\"\305$\216\n\203m\310\n\"\203m\334\202n\335\310\336\"\203\200\314\315\211\337%\202\201\262)\266\202#\207" vconcat vector [org-list-two-spaces-after-bullet-regexp org-list-get-prev-item 2 3 org-list-use-alpha-bul-p org-list-set-bullet string-match "[a-zA-Z]" "[a-z]" "[A-Z]" replace-match nil "[0-9]+" org-list-inc-bullet-maybe "[A-Za-z]" "A" "a" "\\([0-9]+\\|[A-Za-z]\\)" "1" match-data make-byte-code 0 "\301\300\302\"\207" vconcat vector [set-match-data evaporate] " " " " "\\S-+\\([ ]*\\)" 1] 18 "\n\n(fn ITEM)" mapc mapcar car] 10 (#$ . 39929)])
#@317 Verify and correct indentation in STRUCT.
PARENTS is the alist of parents, as returned by
`org-list-parents-alist'.
If numeric optional argument BULLET-SIZE is set, assume all
bullets in list have this length to determine new indentation.
This function modifies STRUCT.
(fn STRUCT PARENTS &optional BULLET-SIZE)
(defalias 'org-list-struct-fix-ind #[770 "\300!\211\301\2368\266\205\302\303\304\305\306 $\307\"\310\311%\312\313\314 A\"\"\207" [org-list-get-top-point 1 make-byte-code 257 "\305\300\301#\211\2030 \306\300\307\302\206 \300\310\2368\266\205G\300\311\2368\266\205\f##\2025 \306\300\303#\207" vconcat vector [org-list-indent-offset org-list-get-parent org-list-set-ind + 2 1] 15 "\n\n(fn ITEM)" mapc mapcar car] 14 (#$ . 41636)])
#@519 Verify and correct checkboxes in STRUCT.
PARENTS is the alist of parents and PREVS is the alist of
previous items, as returned by, respectively,
`org-list-parents-alist' and `org-list-prevs-alist'.
If ORDERED is non-nil, a checkbox can only be checked when every
checkbox before it is checked too. If there was an attempt to
break this rule, the function will return the blocking item. In
all others cases, the return value will be nil.
This function modifies STRUCT.
(fn STRUCT PARENTS PREVS &optional ORDERED)
(defalias 'org-list-struct-fix-box #[1027 "\300\301\"\302\303\304\305\306 \"\307\"\310\311%\312C\313\302\303\314\305\306\f\f#\315\"\316\317%\"\210\211\320\242\302\321\322\305\306!\323\"\324\325%\"\240\210\313\242\"\210\205\242 \300\302\303\326\305\306\f!\327\"\330\317%\"\331\235\332\235\205\240 GGZ\211\233\211\203\217 \211@\211\f\333\2368\266\205\203\210 \334
\331#\210A\266\202\202k \210\335\n\n\n\312$\210\2118\262\266\202\207" [mapcar car make-byte-code 257 "\302\303\304\305\306\307\300!\310\"\311\312%\313\300\301#\"\314\300\315\235\203& \316\235\203& \317\202P \317\235\2030 \317\202P \316\235\203: \316\202P \315\235\203D \315\202P \300\320\2368\266\205#\207" vconcat vector [mapcar make-byte-code 257 "\211\300\301\2368\207" vconcat vector [4] 9 "\n\n(fn CHILD)" org-list-get-children org-list-set-checkbox "[ ]" "[X]" "[-]" 4] 13 "\n\n(fn ITEM)" nil mapc "\303\300\301#\211\300\304\2368\266\205\211\205# \302\242>?\205# \302\302\242B\240\207" [org-list-get-parent 4] 10 "\n\n(fn E)" sort 514 "\300\301\2368\266\205\300\301\2368\266\205V\207" [1] 11 "\n\n(fn E1 E2)" "\211\300\301\2368\207" [4] 9 "[ ]" "[X]" 4 org-list-set-checkbox org-list-struct-fix-box] 20 (#$ . 42419)])
#@99 Verify and correct each item end position in STRUCT.
This function modifies STRUCT.
(fn STRUCT)
(defalias 'org-list-struct-fix-item-end #[257 "\300\211\211\203c \211@\211@\211\211\301\2368\266\205\302 \"\211 \236\204J \303\304#\211\203A \211\n\301\2368\266\205\305\\\202B \306B B\262 \210BB\262\211BB\262\266A\266\202\202 \210\307\310\"\262\311\"\207" [nil 1 org-list-get-item-end assoc-default > 2 0 sort #[514 "AAW\207" [] 4 "\n\n(fn E1 E2)"] org-list-struct-assoc-end] 18 (#$ . 44211)])
#@314 Apply set difference between STRUCT and OLD-STRUCT to the buffer.
OLD-STRUCT is the structure before any modifications, and STRUCT
the structure to be applied. The function will only modify parts
of the list which have changed.
Initial position of cursor is restored after the changes.
(fn STRUCT OLD-STRUCT)
(defalias 'org-list-struct-apply-struct #[514 "\303 \304\305!\205\n \306 \307 \310\311\312\211\211\211\211\n\211\203\221 \211@\211@\211\313\2368\266\205\313\2368\266\205\314\2368\266\205\314\2368\266\205G\\G\\Z\315\"B\fB\262\f\211\236\204 \316\317#BB\262\210\211B
B\262
\266A\266\202\202 \210\320\321\322\323\"\322\323 \"\324!\325!\262\262\"\326\"\262\237\262A\2035\211A\262\242@\236\211\203\316 \236A\202*\236A\211\313\2368\266\205\212b\210`W\203$\327\330\331!)\262\204 \332 ^\262\331\333!\203\334\335\336\337\313!\"\330#\204 \331\n!\203 \334\340\330#\210\312y\210\202\345 )Z\266\203EB\266\205\202\261 \211\211\203t\211@\3148\341U\204N\342 \f\f$\210\211A@\211\236\211\203k\211\236\232\204k #\210\266A\266\202\2026\266b\210\312\211\223\207" [most-positive-fixnum inhibit-changing-match-data org-drawer-regexp point-marker featurep org-inlinetask org-inlinetask-outline-regexp org-item-re #[1285 "b\210\301\302x\210\303 \210`V\204 `U\205F \304!?\205F \203- \304!\203- \305 \210\202@ \306\307\304!)\262\203@ \310\311 \\!\210\312y\210\202\n \207" [inhibit-changing-match-data "
\n" nil beginning-of-line looking-at org-inlinetask-goto-beginning "^[ ]*\\S-" t indent-line-to current-indentation -1] 8 "\n\n(fn INLINETASK-RE ITEM-RE END BEG DELTA)"] #[771 "\211b\210\211\302\2368\266\205\303 \304\2368\266\205\305 \306\307\310\311\312!\313\"\314$\216\203: \315\"\203: \316\202; \317\315\320\"\203M \321\322\211\302%\202N \262)\266\202\304\2368\266\205\323\2368\266\205\324 !\210\232\204~ \321\322\211\211\302%\210\325\314!\232\204\312 \325\314!\203\233 \211\203\233 \321\322\211\211\314%\210\202\312 \325\314!\203\260 \324\326!\210\321\327\322\211\211\302%\210\202\312 \304\225\211\203\273 \211T\202\275 \302\225b\210?\205\306 \317Pc\266U?\205\335 \330 b\331\322w\210`|\210j\207" [org-list-two-spaces-after-bullet-regexp org-list-full-item-re 1 current-indentation 2 match-data make-byte-code 0 "\301\300\302\"\207" vconcat vector [set-match-data evaporate] 3 string-match " " " " "\\S-+\\([ ]*\\)" replace-match nil 4 looking-at match-string ".*?\\([ ]*\\[[ X-]\\]\\)" "" point-at-bol " "] 15 "\n\n(fn STRUCT OLD-STRUCT ITEM)"] nil 1 2 org-list-get-item-end assoc-default > sort append mapcar car copy-sequence delete-dups < "[ ]*$" t looking-at current-indentation "#\\+BEGIN\\(:\\|_\\S-+\\)" re-search-forward format "^[ ]*#\\+END%s[ ]*$" match-string "^[ ]*:END:[ ]*$" 0 apply] 26 (#$ . 44750)])
#@389 Correct bullets, checkboxes and indentation in list at point.
STRUCT is the list structure. PARENTS is the alist of parents,
as returned by `org-list-parents-alist'.
When non-nil, optional argument OLD-STRUCT is the reference
structure of the list. It should be provided whenever STRUCT
doesn't correspond anymore to the real list in buffer.
(fn STRUCT PARENTS &optional OLD-STRUCT)
(defalias 'org-list-write-struct #[770 "\211\206 \300!\301\302#\210\303!\210\304!\305\"\210\301\"\210\306#\266\307\"\266\207" [copy-tree org-list-struct-fix-ind 2 org-list-struct-fix-item-end org-list-prevs-alist org-list-struct-fix-bul org-list-struct-fix-box org-list-struct-apply-struct] 9 (#$ . 47680)])
#@505 Call FUNCTION on each item of the list at point.
FUNCTION must be called with at least one argument: INIT-VALUE,
that will contain the value returned by the function at the
previous item, plus ARGS extra arguments.
FUNCTION is applied on items in reverse order.
As an example, (org-apply-on-list (lambda (result) (1+ result)) 0)
will return the number of items in the current list.
Sublists of the list are skipped. Cursor is always at the
beginning of the item.
(fn FUNCTION INIT-VALUE &rest ARGS)
(defalias 'org-apply-on-list #[642 "\300 \301!\302\303 !\304\305!#\237\211\203, \211@\211b\210\306\n\n#\262A\266\202\202 \210b\210\307\211\223\210\207" [org-list-struct org-list-prevs-alist copy-marker point-at-bol org-list-get-all-items marker-position apply nil] 14 (#$ . 48401)])
#@162 Set visibility of ITEM in STRUCT to VIEW.
Possible values are: `folded', `children' or `subtree'. See
`org-cycle' for more information.
(fn ITEM STRUCT VIEW)
(defalias 'org-list-set-item-visibility #[771 "\211\300\267\202H \301\"\302\212b\210\303 )\304\305$\207\306\307#\210\310!\311#\211\211\205: \211@\306\312#\210A\266\202\202& \262\207\313\"\302\314\305$\207\314\207" [#s(hash-table size 3 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (folded 6 children 23 subtree 61)) org-list-get-item-end-before-blank org-flag-region line-end-position t outline org-list-set-item-visibility subtree org-list-parents-alist org-list-get-children folded org-list-get-item-end nil] 11 (#$ . 49209)])
#@62 Return column at which body of ITEM should start.
(fn ITEM)
(defalias 'org-list-item-body-column #[257 "\212\211b\210\302\303!\210\304\225b\210i\203' \305\304!\306\307\310#)\266\203\203' \311\202( \304\\)\207" [org-list-two-spaces-after-bullet-regexp inhibit-changing-match-data looking-at "[ ]*\\(\\S-+\\)" 1 match-string nil t string-match 2] 9 (#$ . 49943)])
(defalias 'org-list-get-item-begin 'org-in-item-p)
#@77 Go to the beginning of the current item.
Throw an error when not in a list.
(defalias 'org-beginning-of-item #[0 "\300 \211\203 \211b\202 \301\302!\207" [org-in-item-p error "Not in an item"] 3 (#$ . 50370) nil])
#@93 Go to the beginning item of the current list or sublist.
Throw an error when not in a list.
(defalias 'org-beginning-of-item-list #[0 "\300 \211\204\f \301\302!\202 \211b\210\303 \304!\305#b\266\202\207" [org-in-item-p error "Not in an item" org-list-struct org-list-prevs-alist org-list-get-list-begin] 7 (#$ . 50591) nil])
#@82 Go to the end of the current list or sublist.
Throw an error when not in a list.
(defalias 'org-end-of-item-list #[0 "\300 \211\204\f \301\302!\202 \211b\210\303 \304!\305#b\266\202\207" [org-in-item-p error "Not in an item" org-list-struct org-list-prevs-alist org-list-get-list-end] 7 (#$ . 50927) nil])
#@71 Go to the end of the current item.
Throw an error when not in a list.
(defalias 'org-end-of-item #[0 "\300 \211\204\f \301\302!\202 \211b\210\303 \304\"b\262\207" [org-in-item-p error "Not in an item" org-list-struct org-list-get-item-end] 5 (#$ . 51244) nil])
#@171 Move to the beginning of the previous item.
Throw an error when not in a list. Also throw an error when at
first item, unless `org-list-use-circular-motion' is non-nil.
(defalias 'org-previous-item #[0 "\301 \211\204\f \302\303!\2024 \211b\210\304 \305!\306#\211\203\" \211b\2022 \203/ \307#b\2022 \302\310!\266\203\207" [org-list-use-circular-motion org-in-item-p error "Not in an item" org-list-struct org-list-prevs-alist org-list-get-prev-item org-list-get-last-item "On first item"] 8 (#$ . 51516) nil])
#@166 Move to the beginning of the next item.
Throw an error when not in a list. Also throw an error when at
last item, unless `org-list-use-circular-motion' is non-nil.
(defalias 'org-next-item #[0 "\301 \211\204\f \302\303!\2024 \211b\210\304 \305!\306#\211\203\" \211b\2022 \203/ \307#b\2022 \302\310!\266\203\207" [org-list-use-circular-motion org-in-item-p error "Not in an item" org-list-struct org-list-prevs-alist org-list-get-next-item org-list-get-first-item "On last item"] 8 (#$ . 52041) nil])
#@169 Move the item at point down, i.e. swap with following item.
Sub-items (items with larger indentation) are considered part of
the item, so this really moves item trees.
(defalias 'org-move-item-down #[0 "\301 \204 \302\303!\210i\304 \305 \306!\307\304 #\211\204# \204# \310\311!\210\211\2041 \312\313#\262\202B \314#\262\307\306!#b\210\315\316!\"\210\317!\207" [org-list-use-circular-motion org-at-item-p error "Not at an item" point-at-bol org-list-struct org-list-prevs-alist org-list-get-next-item user-error "Cannot move this item further down" org-list-send-item begin org-list-swap-items org-list-write-struct org-list-parents-alist org-move-to-column] 10 (#$ . 52557) nil])
#@166 Move the item at point up, i.e. swap with previous item.
Sub-items (items with larger indentation) are considered part of
the item, so this really moves item trees.
(defalias 'org-move-item-up #[0 "\301 \204 \302\303!\210i\304 \305 \306!\307\304 #\211\204# \204# \310\311!\210\211\2041 \312\313#\262\2028 \314#\262\315\316!\"\210\317!\207" [org-list-use-circular-motion org-at-item-p error "Not at an item" point-at-bol org-list-struct org-list-prevs-alist org-list-get-prev-item user-error "Cannot move this item further up" org-list-send-item end org-list-swap-items org-list-write-struct org-list-parents-alist org-move-to-column] 9 (#$ . 53263) nil])
#@325 Insert a new item at the current level.
If cursor is before first character after bullet of the item, the
new item will be created before the current one.
If CHECKBOX is non-nil, add a checkbox next to the bullet.
Return t when things worked, nil when we are not in an item, or
item is invisible.
(fn &optional CHECKBOX)
(defalias 'org-insert-item #[256 "\301 `?\206 \212b\210\302 )?\205\207 \212b\210\303 )\203$ \304 \210\305\202\207 \212b\210\306 )\307!\310#\311=\2059 \312\313 %\262\314\315!\"\210\203Q \316 \210\317!\210\320\224\203y \321 \322\323\324\325\326!\327\"\330$\216\331\332\333\334!\")\262\203y \320\224\202{ \323\225b\210\211\203\204 \335u\210\305\266\203\207" [org-list-full-item-re org-in-item-p org-invisible-p org-at-item-timer-p org-timer-item t org-list-struct org-list-prevs-alist org-list-get-list-type descriptive " :: " org-list-insert-item org-list-write-struct org-list-parents-alist org-update-checkbox-count-maybe looking-at 4 match-data make-byte-code 0 "\301\300\302\"\207" vconcat vector [set-match-data evaporate] 3 string-match "[.)]" match-string 1 -1] 13 (#$ . 53940) "P"])
#@63 Fix indentation, bullets and checkboxes in the list at point.
(defalias 'org-list-repair #[0 "\300 \204 \301\302!\210\303 \304!\305\"\207" [org-at-item-p error "This is not a list" org-list-struct org-list-parents-alist org-list-write-struct] 5 (#$ . 55080) nil])
#@333 Cycle through the different itemize/enumerate bullets.
This cycle the entire list level through the sequence:
`-' -> `+' -> `*' -> `1.' -> `1)'
If WHICH is a valid string, use that as the new bullet. If WHICH
is an integer, 0 means `-', 1 means `+' etc. If WHICH is
`previous', cycle backwards.
(fn &optional WHICH)
(defalias 'org-cycle-list-bullet #[256 "\303 \204 \304\305!\210\212\306 \210\307 \310!\311!\312`#\211\313\2368\266\205\314#\315\316\317\"\2039 \320\202\206 \316\321\"\203D \322\202\206 \316\323\"\203O \324\202\206 \316\325\"\203Z \326\202\206 \316\327\"\203e \330\202\206 \316\331\"\203p \332\202\206 \315\333\203{ \334\202| \335\336\333\337\336##\266\202\340\341\342\343!?\205\220 \344 \345=\206\230 \346 ?\205\235 \347 \350=\206\245 \346 ?\205\252 \351?\206\270 \345=\206\270 \346 ?\205\275 \352?\206\313 \350=\206\313 \346 ?\205\320 \353&\211G\211\235GZ\354 \235\203\347 \202\f \247\203\366 \211#\202\f \355=\203\211S#\202\f\211T#\356\f!\357\n\360 \361\362\363\364\365!\366\"\367$\216\n\2033\316\n\"\2033\370\2024\371\316\372\"\203F\373\315\211\374%\202G\262)\266\202#\210\375
\f\"\210\376
\"\210\377
\"\262)\266\214)\207" [case-fold-search org-plain-list-ordered-item-terminator org-list-two-spaces-after-bullet-regexp org-at-item-p error "Not at an item" beginning-of-line org-list-struct org-list-parents-alist org-list-prevs-alist org-list-get-first-item 2 org-list-use-alpha-bul-p nil string-match "[a-z]\\." "a." "[a-z])" "a)" "[A-Z]\\." "A." "[A-Z])" "A)" "\\." "1." ")" "1)" replace-regexp-in-string "\\`\\([ ]*\n\\)+" "\\`[ \n
]+" "" "[ \n
]+\\'" append ("-" "+") looking-at "\\S-" ("*") 41 org-at-item-description-p ("1.") 46 ("1)") ("a." "A.") ("a)" "A)") #[771 "\300\"8\207" [mod] 6 "\n\n(fn BULLET-LIST LEN INDEX)"] previous copy-tree org-list-set-bullet match-data make-byte-code 0 "\301\300\302\"\207" vconcat vector [set-match-data evaporate] 3 " " " " "\\S-+\\([ ]*\\)" replace-match 1 org-list-struct-fix-bul org-list-struct-fix-ind org-list-struct-apply-struct] 26 (#$ . 55355) "P"])
#@125 Non-nil if Org-List-Checkbox-Radio mode is enabled.
Use the command `org-list-checkbox-radio-mode' to change this variable.
(defvar org-list-checkbox-radio-mode nil (#$ . 57490))
(make-variable-buffer-local 'org-list-checkbox-radio-mode)
#@331 When turned on, use list checkboxes as radio buttons.
If called interactively, enable Org-List-Checkbox-Radio mode if ARG is
positive, and disable it if ARG is zero or negative. If called from
Lisp, also enable the mode if ARG is omitted or nil, and toggle it if
ARG is `toggle'; disable the mode otherwise.
(fn &optional ARG)
(defalias 'org-list-checkbox-radio-mode #[256 "\302 \303=\203
?\202 \304!\305V \306=\204 \307\310!\210\311\312\203' \313\202( \314\"\210\315\316!\203L \302 \203< \211\302 \232\203L \317\320\321\203G \322\202H \323#\266\210\324 \210\207" [org-list-checkbox-radio-mode major-mode current-message toggle prefix-numeric-value 0 org-mode user-error "Cannot turn this mode outside org-mode buffers" run-hooks org-list-checkbox-radio-mode-hook org-list-checkbox-radio-mode-on-hook org-list-checkbox-radio-mode-off-hook called-interactively-p any " in current buffer" message "Org-List-Checkbox-Radio mode %sabled%s" "en" "dis" force-mode-line-update] 7 (#$ . 57735) (byte-code "\206 \301C\207" [current-prefix-arg toggle] 1)])
(defvar org-list-checkbox-radio-mode-hook nil)
(byte-code "\301\302N\204\f \303\301\302\304#\210\305\306\307\310\300!\205 \311\211%\207" [org-list-checkbox-radio-mode-map org-list-checkbox-radio-mode-hook variable-documentation put "Hook run after entering or leaving `org-list-checkbox-radio-mode'.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it. (This is true for all hook variables.)" add-minor-mode org-list-checkbox-radio-mode " CheckBoxRadio" boundp nil] 6)
#@79 Toggle off all checkboxes and toggle on the one at point.
(fn &optional ARG)
(defalias 'org-toggle-radio-button #[256 "\300 \204 \301\302!\207\303 \304 \305\306\307\"\310!\311!\312\2368\266\205\313!\314\315 #\205< \316\232\205< \211\232?\205A \317\320 \313 !#\211\203^ \211@\321 #\210A\266\202\202J \210\211\203\221 \321 \f\322\267\202\203 ?\205\217 \317\202\217 ?\205\217 \323\202\217 \324\232\203\216 \317\202\217 \324#\210\325\n$\210\326\"\210\327 \207" [org-at-item-p user-error "Cannot toggle checkbox outside of a list" org-in-item-p org-list-struct org-entry-get nil "ORDERED" org-list-parents-alist copy-tree 4 org-list-prevs-alist org-list-get-list-begin point-at-bol (4) "[ ]" org-list-get-all-items org-list-set-checkbox #s(hash-table size 2 test equal rehash-size 1.5 rehash-threshold 0.8125 purecopy t data ((4) 111 (16) 121)) "[-]" "[X]" org-list-struct-fix-box org-list-struct-apply-struct org-update-checkbox-count-maybe] 16 (#$ . 59311) "P"])
#@45 Is point at a list item with radio buttons?
(defalias 'org-at-radio-list-p #[0 "\301\302 !\205V \212\303 \210\304 )\305!\306>\205T \307\310\311#\312\313\"\212\314!\203+ \315!q\210\212\214~\210\211\2064 `b\210\311\316\312\317\"\320\311#\205L \321\322!\323\230?)\266\203+\262\262\262\207" [case-fold-search org-match-line org-item-re beginning-of-line org-element-at-point org-element-type (item plain-list) org-element-lineage (plain-list) t org-element-property :post-affiliated markerp marker-buffer "^[ ]*#\\+attr_org:.* :radio \\(\\S-+\\)" :begin re-search-backward match-string 1 "nil"] 10 (#$ . 60324)])
#@551 Toggle the checkbox in the current line.
With prefix argument TOGGLE-PRESENCE, add or remove checkboxes.
With a double prefix argument, set the checkbox to "[-]".
When there is an active region, toggle status or presence of the
first checkbox there, and make every item inside have the same
status or presence, respectively.
If point is on a headline, apply this to all checkbox items in
the text below the heading, taking as reference the first item in
subtree, ignoring planning line and any drawer following it.
(fn &optional TOGGLE-PRESENCE)
(defalias 'org-toggle-checkbox #[256 "\300 \203\f \301!\210\202\251\212\302\211\211C\302C\303\302\304\"\305 \203C \306 \307 b\210\310\311\312 P\313#\2035 \314 \240\210\2029 \315\316!\210\317!\240\262\202\214 \320 \203s \212\321 \210`)\322\313!\210\310\311\312 P\313#\203e \314 \240\210\202i \315\323!\210\317!\240\262\202\214 \324 \203\211 \313\262\314 \240\210\317\325 !\240\202\214 \315\326!\242b\210\327 \205\230 \330\331!\332\267\202\254 \333\202\267 \211?\205\267 \334\202\267 \211\335\232\203\266 \334\202\267 \335\262\242b\210`\242W\203\241\310\311\312 P\242\336#\203\241\337 \340!\341!\342!\317\343!!\344\345\346\347\350\351\"\352\"\353\354%\355\356\"\"\211\211\203*\211@\357 \360\2368\266\205\211\204\361\232\203 \f\202 \211\262#\210A\266\202\202\367 \210\362\f$\262\f\f\203j \203j\n\242\fV\203j\315\363
\212\211\203T\211b\210n\203\\\331\202]\364\365\331`\"\\)\262\"\210\202\216 \203\216\366\367
\212\211\203{\211b\210n\203\203\331\202\204\364\365\331`\"\\)\262\"\210b\210\302\211\223\210\370\"\266\202\275 \242\302\211\223\266)\371 \207" [org-at-radio-list-p org-toggle-radio-button nil org-entry-get "ORDERED" org-region-active-p region-end region-beginning org-list-search-forward "^" org-item-re t point-at-bol error "No item in region" copy-marker org-at-heading-p outline-next-heading org-end-of-meta-data "No item in subtree" org-at-item-p point-at-eol "Not at an item or heading, and no active region" org-at-item-checkbox-p match-string 1 #s(hash-table size 2 test equal rehash-size 1.5 rehash-threshold 0.8125 purecopy t data ((16) 159 (4) 163)) "[-]" "[ ]" "[X]" move org-list-struct copy-tree org-list-parents-alist org-list-prevs-alist org-list-get-bottom-point cl-remove-if make-byte-code 257 "\211\300\242W\206 \211\301\242V\207" vconcat vector [] 3 "\n\n(fn E)" mapcar car org-list-set-checkbox 4 (4) org-list-struct-fix-box "Checkbox blocked because of unchecked box at line %d" 0 count-lines message "Checkboxes were removed due to unchecked box at line %d" org-list-struct-apply-struct org-update-checkbox-count-maybe] 27 (#$ . 60954) "P"])
#@43 Reset all checkboxes in an entry subtree.
(defalias 'org-reset-checkbox-state-subtree #[0 "\300 \203 \301\302!\207\214\212\303 \210\304 \210eb\210d`W\203/ \305 \203( \306\307\310\211\311\312%\210\313\314!\210\202 \210\315\316!*\207" [org-before-first-heading-p error "Not inside a tree" org-narrow-to-subtree org-show-subtree org-at-item-checkbox-p replace-match "[ ]" t nil 1 beginning-of-line 2 org-update-checkbox-count-maybe all] 7 (#$ . 63668) "*"])
#@244 Update the checkbox statistics in the current section.
This will find all statistic cookies like [57%] and [6/12] and
update them with the current numbers.
With optional prefix argument ALL, do this for the whole buffer.
(fn &optional ALL)
(defalias 'org-update-checkbox-count #[256 "\212\214~\210\306\307?\206 \310\311\312\313\314\"\206 \315\"?\205# \316\317!\205# \320 \203+ d\202J \211\2038 \212\321 \210`)\202J \212\322\323 \211\324\nP \321 \210,`)\325\313\211\203X eb\210\202r \203c \326\322!\210\202r \322\323 \211\324\nP \327 \210,\330\322#\203N\212\331u\210\332 \333\334\335\336\337!\340\"\341$\216\342 )\262)\343!\344=\203J\345\346\224\346\225\347\225E\350\351\"\211\203\262 \352\353\"\202\304 \212\322\323 \211\324\nP \327 \210,`)\211\236A\206C\212\211b\210\203\333 \352\354\"\202\355 \212\322\323 \211\324\nP \321 \210,`)\313\330\322#\203\"\355 \343!\356=\203 \352\357\"B\262\350\360\"\211\262\203 \352\361\"^b\210\202 \210\202\356 \343!\356=\2051\352\362\"#B B\262 \211\262\266\202)\266\202\"B\262\210\202r \211\205\230\211@\211@A@\3478\3418\3638b\210\203x\364\365\366\367_\346]\"\"\202}\364\370#c\210``Z\\|\210
\203\217\371 \210\266A\266\202\202O\262\266\210*\207" [org-checkbox-hierarchical-statistics org-called-with-limited-levels org-outline-regexp outline-regexp org-outline-regexp-bol org-auto-align-tags "\\(\\(\\[[0-9]*%\\]\\)\\|\\(\\[[0-9]*/[0-9]*\\]\\)\\)" "^[ ]*\\([-+*]\\|\\([0-9]+\\|[A-Za-z]\\)[.)]\\)[ ]+\\(?:\\[@\\(?:start:\\)?\\([0-9]+\\|[A-Za-z]\\)\\][ ]*\\)?\\(\\[[- X]\\]\\)" string-match "\\<recursive\\>" org-entry-get nil "COOKIE_DATA" "" featurep org-inlinetask org-inlinetask-in-task-p outline-next-heading t org-get-limited-outline-regexp "^" #[771 "\300\211\211\203p \211@\301!\302!\203! \203! \303 \"\202B \203- \304\305\"\202B \203; \306 #\202B \307\310!#\311\312\304\313\314\315\316\317 !\320\"\321\322%\"\"G\\\262\323\324\325\326$\\\262\266A\266\202\202 D\262\207" [0 org-list-prevs-alist org-list-parents-alist org-list-get-subtree mapcar car org-list-get-children org-list-get-all-items org-list-get-top-point delq nil make-byte-code 257 "\211\300\301\2368\207" vconcat vector [4] 9 "\n\n(fn E)" cl-count "[X]" :test equal] 19 "\n\n(fn ITEM STRUCTS RECURSIVEP)"] org-back-to-heading outline-previous-heading re-search-forward -1 match-data make-byte-code 0 "\301\300\302\"\207" vconcat vector [set-match-data evaporate] 3 org-element-context org-element-type statistics-cookie append 1 2 org-element-lineage (drawer center-block dynamic-block inlinetask item quote-block special-block verse-block) org-element-property :contents-begin :contents-end org-element-at-point item :structure (plain-list) :end :begin 4 format "[%d%%]" floor 100.0 "[%d/%d]" org-fix-tags-on-the-fly] 23 (#$ . 64133) "P"])
#@140 Select the face for checkbox statistics.
The face will be `org-done' when all relevant boxes are checked.
Otherwise it will be `org-todo'.
(defalias 'org-get-checkbox-statistics-face #[0 "\300\225\203 \301\300!\302\232\203 \303\207\304\207\305\225\305\224V\203% \301\305!\301\306!\232\203% \303\207\304\207" [1 match-string "100%" org-checkbox-statistics-done org-checkbox-statistics-todo 2 3] 3 (#$ . 67017)])
#@139 Update checkbox statistics unless turned off by user.
With an optional argument ALL, update them in the whole buffer.
(fn &optional ALL)
(defalias 'org-update-checkbox-count-maybe #[256 "\301\236A\203 \302!\210\303\304!\207" [org-list-automatic-rules checkbox org-update-checkbox-count run-hooks org-checkbox-statistics-hook] 3 (#$ . 67437)])
(defvar org-last-indent-begin-marker (make-marker))
(defvar org-last-indent-end-marker (make-marker))
#@350 Indent a local list item including its children.
When number ARG is a negative, item will be outdented, otherwise
it will be indented.
If a region is active, all items inside will be moved.
If NO-SUBTREE is non-nil, only indent the item itself, not its
children.
STRUCT is the list structure.
Return t if successful.
(fn ARG NO-SUBTREE STRUCT)
(defalias 'org-list-indent-item-generic #[771 "\212\306 \211\205 \307 \205 \310 \311!\312!\313!?\2058 \314 U\2058 \315\236A\2058 \2037 \316\317!\2028 \320 \321>\203D \n\322>\204} \203W \323\223\210\f\323\223\210\202} \314 \323\223\210\f\203i \324 !\202z \203t \314 T\202z \325\314 \n\"\323\223\210\326 !\326\f!\203M\327 \f\330W\203\225 \211[\202\226 \211\f\331\2368\266\205\332
!\\\330W\203\266 \333\334!\210\202H\\\330U\203\335\336\337\2368\266\205\"\203\340\341\342 \343\330\344\345\346!\347\"\350$\216
\203\365 \335
\"\203\365 \351\202\366 \352\335\353\"\203\354\323\211\331%\202 \262)\266\202#\210
\211\203:\211@\211@\211\211\331\2368\266\205\355 \\#\266A\266\202\202\210\356 \"\210\357\"\210\266\202\267 \330W\203\214\n\203f\204f\360 \"\204\205\361\362\343\363\364\345\346!\365\"\350\366%\f\"!@@\360\f\"\262\203\214\333\367!\210\202\267\332\n!\f\330W\203\242\370
$\202\254\371
%\372\f#\266\373 \210\266 )\320\207" [org-list-automatic-rules last-command this-command org-last-indent-begin-marker org-last-indent-end-marker org-list-two-spaces-after-bullet-regexp org-region-active-p region-beginning region-end org-list-get-top-point org-list-parents-alist org-list-prevs-alist point-at-bol indent user-error "At first item: use S-M-<left/right> to move the whole list" t (org-shiftmetaright org-shiftmetaleft) (org-shiftmetaright org-shiftmetaleft) nil org-list-get-bottom-point org-list-get-item-end marker-position org-level-increment 0 1 copy-tree error "Cannot outdent beyond margin" string-match "\\*" 2 org-list-set-bullet "-" match-data make-byte-code "\301\300\302\"\207" vconcat vector [set-match-data evaporate] 3 " " " " "\\S-+\\([ ]*\\)" replace-match org-list-set-ind org-list-struct-fix-bul org-list-struct-apply-struct org-list-has-child-p reverse cl-remove-if 257 "\211@\300Y\207" [] "\n\n(fn E)" "Cannot outdent an item without its children" org-list-struct-outdent org-list-struct-indent org-list-write-struct org-update-checkbox-count-maybe] 28 (#$ . 67893)])
#@105 Outdent a local list item, but not its children.
If a region is active, all items inside will be moved.
(defalias 'org-outdent-item #[0 "\300 \301 \204 \211\2031 \212\302 b\210\301 )\2031 \211\204 \303 \202' \212\302 b\210\303 )\304\305\306#\262\202> \211\203; \307\310!\202> \307\311!\207" [org-region-active-p org-at-item-p region-beginning org-list-struct org-list-indent-item-generic -1 t error "Region not starting at an item" "Not at an item"] 6 (#$ . 70367) nil])
#@104 Indent a local list item, but not its children.
If a region is active, all items inside will be moved.
(defalias 'org-indent-item #[0 "\300 \301 \204 \211\2031 \212\302 b\210\301 )\2031 \211\204 \303 \202' \212\302 b\210\303 )\304\305\306#\262\202> \211\203; \307\310!\202> \307\311!\207" [org-region-active-p org-at-item-p region-beginning org-list-struct org-list-indent-item-generic 1 t error "Region not starting at an item" "Not at an item"] 6 (#$ . 70849) nil])
#@106 Outdent a local list item including its children.
If a region is active, all items inside will be moved.
(defalias 'org-outdent-item-tree #[0 "\300 \301 \204 \211\2031 \212\302 b\210\301 )\2031 \211\204 \303 \202' \212\302 b\210\303 )\304\305\306#\262\202> \211\203; \307\310!\202> \307\311!\207" [org-region-active-p org-at-item-p region-beginning org-list-struct org-list-indent-item-generic -1 nil error "Region not starting at an item" "Not at an item"] 6 (#$ . 71328) nil])
#@105 Indent a local list item including its children.
If a region is active, all items inside will be moved.
(defalias 'org-indent-item-tree #[0 "\300 \301 \204 \211\2031 \212\302 b\210\301 )\2031 \211\204 \303 \202' \212\302 b\210\303 )\304\305\306#\262\202> \211\203; \307\310!\202> \307\311!\207" [org-region-active-p org-at-item-p region-beginning org-list-struct org-list-indent-item-generic 1 nil error "Region not starting at an item" "Not at an item"] 6 (#$ . 71818) nil])
#@272 Cycle levels of indentation of an empty item.
The first run indents the item, if applicable. Subsequent runs
outdent it at meaningful levels in the list. When done, item is
put back at its original position with its original bullet.
Return t at each successful move.
(defalias 'org-cycle-item-indentation #[0 "\304 \205 \305 \306 \211\307\2368\266\205\310=\2044 \311 !\205 \312\225\212\313\"b\210\314\315x\210`)Y\205 \310\316!\317!\310=\203\303 \320@A\211V\203d \321\n\315\n#\203d \322\307\323
#\202\272 W\203\201 \n\f\n\n$\203\201 \322\324\323
#\202\272 \306 \325 |\210\211j\210\326\261\210\305 \317!\nV\203\260 \f\316!$\203\260 \322\324\323#\202\270 \327\"\210\330\323\266\202\266\202\266\202\266\202\202\315\306 \203\317 `\202\321 \325 {\262\315\331\203\336 \332\202\337 \333\334\331\335\334##\266\202B\321\315#\203\374 \322\307\323#\202\336\315#\204\337#\203\322\324\323#\202\330\340\341!\266\202\266\203\207" [last-command org-list-full-item-re this-command org-tab-ind-state org-at-item-p org-list-struct line-beginning-position 1 org-cycle-item-indentation org-match-line 0 org-list-get-item-end " \n" nil org-list-prevs-alist org-list-parents-alist #[1028 "\300\301#?\205 \302\"?\205 \303#\207" [org-list-get-next-item nil org-list-has-child-p org-list-get-parent] 8 "\n\n(fn ITEM STRUCT PREVS PARENTS)"] org-list-get-prev-item org-list-indent-item-generic t -1 line-end-position " " org-list-write-struct identity replace-regexp-in-string "\\`\\([ ]*\n\\)+" "\\`[ \n
]+" "" "[ \n
]+\\'" org-list-get-next-item org-list-get-parent user-error "Cannot move item"] 18 (#$ . 72305)])
#@1516 Sort list items.
The cursor may be at any item of the list that should be sorted.
Sublists are not sorted. Checkboxes, if any, are ignored.
Sorting can be alphabetically, numerically, by date/time as given
by a time stamp, by a property or by priority.
Comparing entries ignores case by default. However, with an
optional argument WITH-CASE, the sorting considers case as well,
if the current locale allows for it.
The command prompts for the sorting type unless it has been given
to the function through the SORTING-TYPE argument, which needs to
be a character, among ?n ?N ?a ?A ?t ?T ?f ?F ?x or ?X. Here is
the detailed meaning of each character:
n Numerically, by converting the beginning of the item to a number.
a Alphabetically. Only the first line of item is checked.
t By date/time, either the first active time stamp in the entry, if
any, or by the first inactive one. In a timer list, sort the timers.
x By "checked" status of a check list.
Capital letters will reverse the sort order.
If the SORTING-TYPE is ?f or ?F, then GETKEY-FUNC specifies
a function to be called with point at the beginning of the
record. It must return a value that is compatible with COMPARE-FUNC,
the function used to compare entries.
Sorting is done against the visible part of the headlines, it
ignores hidden links.
A non-nil value for INTERACTIVE? is used to signal that this
function is being called interactively.
(fn &optional WITH-CASE SORTING-TYPE GETKEY-FUNC COMPARE-FUNC INTERACTIVE\=\?)
(defalias 'org-sort-list #[1280 "\203 \301\202 \302\303 \304!\305\306 #\307\306 #\206% \310\311!\210\312 \211\227\211\313U\205@ \206@ \203= \314\315!\206@ \316\317!\320U\203J \321\202r \313U\203a \206r \205r \314\322\323\"\202r \324U\203k \325\202r \326U\205r \327\310\330!\210\214}\210eb\210\331\332 \333\334\335\336\337\340!\341\"\342$\334\335\343\337\340\f\f\f %\344\"\345$\346 U?\331\n&\210\347 \210\350\351!\210\310\352!)\266\204)\207" [case-fold-search identity downcase org-list-struct org-list-prevs-alist org-list-get-list-begin point-at-bol org-list-get-list-end message "Sort plain list: [a]lpha [n]umeric [t]ime [f]unc [x]checked A/N/T/F/X means reversed:" read-char-exclusive 102 org-read-function "Function for extracting keys: " error "Missing key extractor" 97 org-string-collate-lessp "Function for comparing keys (empty for default `sort-subr' predicate): " allow-empty 116 < 120 string< "Sorting items..." nil current-time #[0 "\300\301w\210m\206\n \302 \207" ["
\n" nil beginning-of-line] 2] make-byte-code 0 "\301`\300\"b\207" vconcat vector [org-list-get-item-end-before-blank] 3 "\306\307!\205\217 \302\310U\203 \311\312\313\225\314 {!!\207\302\315U\203& \300\312\313\225\314 {!!\207\302\316U\203X \317 \2037 \320\321\322!!\207\212\323
\314 \324#)\204N \212\323 \314 \324#)\203T \325\321\313!!\207\326\304!\207\302\327U\203m \321\322!;\203k \321\322!\206\217 \330\207\302\331U\203\213 \303\203\206 \303 \211;\203\204 \300!\202\205 \211\207\332\333\303\"\207\332\334\301\"\207" [org-ts-regexp looking-at "[ ]*[-+*0-9.)]+\\([ ]+\\[[- X]\\]\\)?[ ]+" 110 string-to-number org-sort-remove-invisible 0 point-at-eol 97 116 org-at-item-timer-p org-timer-hms-to-secs match-string 1 re-search-forward t org-time-string-to-seconds float-time 120 "" 102 error "Invalid key function `%s'" "Invalid sorting type `%c'" org-ts-regexp-both] 4 sort-subr org-list-repair run-hooks org-after-sorting-entries-or-items-hook "Sorting items...done"] 27 (#$ . 73998) (byte-code "\301\211\211\302\257\207" [current-prefix-arg nil t] 5)])
#@438 Convert headings or normal lines to items, items to normal lines.
If there is no active region, only the current line is considered.
If the first non blank line in the region is a headline, convert
all headlines to items, shifting text accordingly.
If it is an item, convert all items to normal lines.
If it is normal text, change region into a list of items.
With a prefix argument ARG, change the region in a single item.
(fn ARG)
(defalias 'org-toggle-item #[257 "\306\307\310\211\311 \203 \312 !\262\313\314 !\262\202\" \315 \262\313\316 !\262\317\320 \211\321 P\212b\210\322 \203P `W\205\374\322 \203J \323\310w\210`\324\225|\210\310y\210\2026 \325 \2038\310 \326 \210)\327\330 \331\324\332\333\334!\335\"\336$\216
\203y \337
\"\203y \340\202z \341\337\342\"\203\214 \343\310\211\344%\202\215 \262)\266\202\211G\212:\204\236 \324\202\253 \345 \204\247 \324\202\253 \346\324!G)\347\350 !`W\2053\347\350 !\324Z]\351 W\203\312 \262\310 \326 \210)\310 ;\352<!\210)`\336\224\206\341 \353 |\210c\210\354_\\!\210\211\203\355 \356!\357\360 =\235\203\361\202 \362#\210\363\364!#\266\212\365 \206`)\310y\210 T _\\\n^\"\266\202\260 \266\204\202\374\203\243\327\330 \331\324\332\333\334!\335\"\336$\216
\203Z\337
\"\203Z\340\202[\341\337\342\"\203m\343\310\211\344%\202n\262)\266\202\211G\366 \323\310w\210c\210\310y\210`W\205\236\\\212\365 \206\224`)^\"\210\310y\210\202\201\266\203\202\374`W\205\374\325 \204\366\322 \204\366\352\367!\203\366\343\370\327\330 \331\324\332\333\334!\335\"\336$\216
\203\331\337
\"\203\331\340\202\332\341\337\342\"\203\354\343\310\211\344%\202\355\262)\266\202\371Q!\210\310y\210\202\243-\207" [org-called-with-limited-levels org-outline-regexp outline-regexp org-outline-regexp-bol org-loop-over-headlines-in-active-region org-list-two-spaces-after-bullet-regexp #[514 "\301\302!\212\3032? `W\205> \304 \305\306!\2047 \305!\2047 \211\307U\203. \310\303\307\211\262\"\210\2027 \211W\2037 \211\262\210\311y\210\202 0\210)Z`W\205c \305\306!\204] \305!\204] \312\304 \\!\210\311y\210\202D \262\207" [org-outline-regexp-bol 1000 copy-marker exit current-indentation looking-at "^[ ]*$" 0 throw nil indent-line-to] 9 "\n\n(fn IND END)"] #[257 "\212\211b\210\300\301w\210\302 )\207" ["
\n" nil point-at-bol] 3 "\n\n(fn POS)"] nil org-region-active-p region-beginning copy-marker region-end point-at-bol point-at-eol t org-get-limited-outline-regexp "^" org-at-item-p " " 0 org-at-heading-p org-list--delete-metadata "-" match-data make-byte-code "\301\300\302\"\207" vconcat vector [set-match-data evaporate] 3 string-match " " " " "\\S-+\\([ ]*\\)" replace-match 1 outline-previous-heading match-string org-reduced-level org-outline-level org-get-todo-state looking-at line-end-position indent-line-to org-list-struct copy-tree org-list-set-checkbox line-beginning-position "[X]" "[ ]" org-list-write-struct org-list-parents-alist outline-next-heading current-indentation "\\([ ]*\\)\\(\\S-\\)" "\\1" "\\2" org-adapt-indentation case-fold-search org-todo-line-regexp org-done-keywords] 20 (#$ . 77611) "P"])
#@555 Parse the list at point and maybe DELETE it.
Return a list whose car is a symbol of list type, among
`ordered', `unordered' and `descriptive'. Then, each item is
a list of strings and other sub-lists.
For example, the following list:
1. first item
+ sub-item one
+ [X] sub-item two
more text in first item
2. [@3] last item
is parsed as
(ordered
("first item"
(unordered
("sub-item one")
("[X] sub-item two"))
"more text in first item")
("[@3] last item"))
Point is left at list's end.
(fn &optional DELETE)
(defalias 'org-list-to-lisp #[256 "\301C\301C\301C\301\211\211C\301C\301C\302 \240\210\303 \242!\240\210\304 \242!\240\210\305\242!\262\306\242!\262\307\240\210\310\311\312\313\314
#\315\"\316\317%\240\210\211\310\311\320\313\314
%\321\"\322\317%\240\210\242\323\n\242\n\242#!b\210 \203\214 |\210\324\325!\204\214 \324!\203\214 \326\327!\210\207" [org-list-end-re nil org-list-struct org-list-prevs-alist org-list-parents-alist org-list-get-top-point org-list-get-bottom-point #[257 "\301\302\303\304\305#)\266\203\203 \306\307\310#\202 !\207" [inhibit-changing-match-data org-remove-indentation "\n\\'" nil t string-match substring 0 -1] 9 "\n\n(fn TEXT)"] make-byte-code 257 "\303@\300\242\301\242#\304\302\242\"B\207" vconcat vector [org-list-get-list-type mapcar] 5 "\n\n(fn E)" "\305\300\242\"\306\300\242\302\242#\212b\210\307\310!\210\303\242\311\312\313\314!!\315\"\316\314\225@\206' \"P!)C\203n @\317\300\242\301\242#\320!@\304\242!B\262\211>A\262\305\300\242\"@\206W U\204i \303\242\316\"!B\262\266\202, \211\237\207" [org-list-get-item-end org-list-get-children looking-at "[ ]*\\S-+[ ]*" make-string string-width match-string 0 32 buffer-substring-no-properties org-list-get-all-items last] 13 org-list-get-all-items looking-at "[ ]*$" replace-match ""] 20 (#$ . 80778)])
#@49 Convert the plain list at point into a subtree.
(defalias 'org-list-make-subtree #[0 "\300 \211\204\n \301\302!\210\211b\210\303 \211\204 \304\202 \211\305!T\262\262\212\306\307!)\310\"\311\261\266\202\207" [org-in-item-p error "Not in a list" org-current-level 1 org-reduced-level org-list-to-lisp t org-list-to-subtree "\n"] 6 (#$ . 82701) nil])
#@2387 Convert a LIST parsed through `org-list-to-lisp' to a custom format.
LIST is a list as returned by `org-list-to-lisp', which see.
PARAMS is a property list of parameters used to tweak the output
format.
Valid parameters are:
:backend, :raw
Export back-end used as a basis to transcode elements of the
list, when no specific parameter applies to it. It is also
used to translate its contents. You can prevent this by
setting :raw property to a non-nil value.
:splice
When non-nil, only export the contents of the top most plain
list, effectively ignoring its opening and closing lines.
:ustart, :uend
Strings to start and end an unordered list. They can also be
set to a function returning a string or nil, which will be
called with the depth of the list, counting from 1.
:ostart, :oend
Strings to start and end an ordered list. They can also be set
to a function returning a string or nil, which will be called
with the depth of the list, counting from 1.
:dstart, :dend
Strings to start and end a descriptive list. They can also be
set to a function returning a string or nil, which will be
called with the depth of the list, counting from 1.
:dtstart, :dtend, :ddstart, :ddend
Strings to start and end a descriptive term.
:istart, :iend
Strings to start or end a list item, and to start a list item
with a counter. They can also be set to a function returning
a string or nil, which will be called with two arguments: the
type of list and the depth of the item, counting from 1.
:icount
Strings to start a list item with a counter. It can also be
set to a function returning a string or nil, which will be
called with three arguments: the type of list, the depth of the
item, counting from 1, and the counter. Its value, when
non-nil, has precedence over `:istart'.
:isep
String used to separate items. It can also be set to
a function returning a string or nil, which will be called with
two arguments: the type of list and the depth of the item,
counting from 1. It always start on a new line.
:ifmt
Function to be applied to the contents of every item. It is
called with two arguments: the type of list and the contents.
:cbon, :cboff, :cbtrans
String to insert, respectively, an un-checked check-box,
a checked check-box and a check-box in transitional state.
(fn LIST PARAMS)
(defalias 'org-list-to-generic #[514 "\302\303!\210\304\305\"\306\307\206 \310\311\312\313!B\314\315!B\316BB$\317\211\320\321!r\211q\210\322\323\324\325\326!\327\"\330$\216\331\332 \210)\317C\317C\322\333\334\325\326!\335\"\336\337%\240\210\211\322\340\341\325\326!\342\"\343\344%\240\210\242 !\266\345\346 \312\347\317\331%\262\350\317#\262*\210\203\215 9\203\215 \351!\204\215 \352\353!\210\204\225 \302\354!\210\203\246 \304\355\"\203\246 \345 \356#\210\357#\360!\203\271 \361\323\362#\202\272 \363\262\207" [org-inhibit-startup org-element-all-objects require ox plist-get :backend org-export-create-backend :parent org :transcoders plain-list org-list--to-generic-plain-list item org-list--to-generic-item ((macro lambda (m c i) (org-element-macro-interpreter m nil))) nil generate-new-buffer " *temp*" make-byte-code 0 "\301\300!\205 \302\300!\207" vconcat vector [buffer-name kill-buffer] 2 t org-mode 257 "\211A\211\205 \211@\300\242@\"\210A\266\202\202 \207" [] 6 "\n\n(fn L)" 514 "`\302=\203 \303\202\f \304c\210\211\203/ \211@\211:\203\" \300\242!\210\202( \211c\210\305c\210A\266\202\202 \210\306 \210\212\302=\203> \307\202? \310`V\205Z \311\312\313!)\262\204T \211j\210\314y\210\202? \262)\207" [inhibit-changing-match-data ordered "1. " "- " "\n" beginning-of-line 3 2 "[ ]*$" t looking-at -1] 7 "\n\n(fn I TYPE)" org-element-map org-element-parse-buffer identity org-export-get-environment org-export-get-backend user-error "Unknown :backend value" ox-org :raw #[257 "\300\301!\"\207" [org-element-set-element org-element-interpret-data] 5 "\n\n(fn OBJECT)"] org-export-data-with-backend org-string-nw-p substring-no-properties -1 ""] 16 (#$ . 83065)])
#@113 Return the level of ELEMENT within current plain list.
ELEMENT is either an item or a plain list.
(fn ELEMENT)
(defalias 'org-list--depth #[257 "\300\301\302\303\304#\"\207" [cl-count-if #[257 "\300!\301=\207" [org-element-type plain-list] 3 "\n\n(fn ANCESTOR)"] org-element-lineage nil t] 7 (#$ . 87183)])
#@64 Return the number of trailing newlines in STRING.
(fn STRING)
(defalias 'org-list--trailing-newlines #[257 "\300\301!r\211q\210\302\303\304\305\306!\307\"\310$\216c\210\311\312x\210\313\314\310!d\"*\207" [generate-new-buffer " *temp*" make-byte-code 0 "\301\300!\205 \302\300!\207" vconcat vector [buffer-name kill-buffer] 2 " \n" nil count-lines line-beginning-position] 8 (#$ . 87499)])
#@162 Evaluate VALUE according to its type.
VALUE is either nil, a string or a function. In the latter case,
it is called with arguments ARGS.
(fn VALUE &rest ARGS)
(defalias 'org-list--generic-eval #[385 "\204 \300\207;\203
\207\301!\203 \302\"\207\303\304\"\207" [nil functionp apply error "Wrong value: %s"] 5 (#$ . 87900)])
#@125 Return a transcoder for `plain-list' elements.
PARAMS is a plist used to tweak the behavior of the transcoder.
(fn PARAMS)
(defalias 'org-list--to-generic-plain-list #[257 "\300\301\"\300\302\"\300\303\"\300\304\"\300\305\"\300\306\"\300\307\"\300\310\"\311\312\313\314\315\f\f\f\f\f\f\f\f&\316\"\317\320%\207" [plist-get :ustart :uend :ostart :oend :dstart :dend :splice :backend make-byte-code 771 "\310\311\"\312!\306?\205 \313\314\267\202 \302\202 \300\202 \304\"\306?\2055 \313\315\267\2022 \303\2023 \301\2023 \305\"\211\203B \316\317\320!#\210\205I \321P\204Y \204Y \306\204Y \307\204^ \202g \322\307 $Q\207" vconcat vector [org-element-property :type org-list--depth org-list--generic-eval #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (ordered 19 unordered 23)) #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (ordered 42 unordered 46)) org-element-put-property :post-blank org-list--trailing-newlines "\n" org-export-with-backend] 13 "\n\n(fn PLAIN-LIST CONTENTS INFO)"] 22 (#$ . 88241)])
#@119 Return a transcoder for `item' elements.
PARAMS is a plist used to tweak the behavior of the transcoder.
(fn PARAMS)
(defalias 'org-list--to-generic-item #[257 "\300\301\"\300\302\"\300\303\"\300\304\"\300\305\"\300\306\"\300\307\"\300\310\"\300 \311\"\300\n\312\"\300 \313\"\300\f\314\"\300
\315\"\316\317\320\321\322&
\323\"\324\325%\207" [plist-get :backend :istart :iend :isep :icount :ifmt :cboff :cbon :cbtrans :dtstart :dtend :ddstart :ddend make-byte-code 771 "\315\316\315\317\"\"\315\320\"\321!\322\"\205 \323\303#\323\302#\211\324\235\203+ \325\202I \203E \211\326\327\"\325\232\203= \211\202@ \211\325P\262\202I \211\211\262\262\206P \211\211\203` \330 \331\332!S\333]#\210\210\315\334 \"\211\203y \304\203y \323\304$\202\200 \323\301#\262\301\204\270 \302\204\270 \304\204\270 \305\204\270 \307\204\270 \306\204\270 \310\204\270 \300\203\270 \335=\203 \311\204\270 \312\204\270 \313\204\270 \314\203 \315\336\n\"\211\337\267\202\317 \307\202\320 \306\202\320 \310\202\320 \340\262\205\353 \311\300\203\345 \341\300 #\202\351 \342!\312Q\205\361 \313\nG\333U\203\375 \343\202\326 \333\327#\305\203\323\305 #\202\211\262\205\314\260\202'\344\300\n\n\n$\211\343\232\2031\343\2028\326\345!\333\327#\262R\207" vconcat vector [org-element-property :type :parent :tag org-list--depth org-export-get-next-element org-list--generic-eval (#1="" nil) "\n" substring -1 org-element-put-property :post-blank org-list--trailing-newlines 0 :counter descriptive :checkbox #s(hash-table size 3 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (on 195 off 199 trans 203)) nil org-export-data-with-backend org-element-interpret-data #1# org-export-with-backend org-element-normalize-string] 17 "\n\n(fn ITEM CONTENTS INFO)"] 32 (#$ . 89369)])
#@241 Convert LIST into a LaTeX list.
LIST is a parsed plain list, as returned by `org-list-to-lisp'.
PARAMS is a property list with overruling parameters for
`org-list-to-generic'. Return converted list as a string.
(fn LIST &optional PARAMS)
(defalias 'org-list-to-latex #[513 "\300\301!\210\302\303\304\"\"\207" [require ox-latex org-list-to-generic org-combine-plists (:backend latex)] 7 (#$ . 91240)])
#@240 Convert LIST into a HTML list.
LIST is a parsed plain list, as returned by `org-list-to-lisp'.
PARAMS is a property list with overruling parameters for
`org-list-to-generic'. Return converted list as a string.
(fn LIST &optional PARAMS)
(defalias 'org-list-to-html #[513 "\300\301!\210\302\303\304\"\"\207" [require ox-html org-list-to-generic org-combine-plists (:backend html)] 7 (#$ . 91652)])
#@243 Convert LIST into a Texinfo list.
LIST is a parsed plain list, as returned by `org-list-to-lisp'.
PARAMS is a property list with overruling parameters for
`org-list-to-generic'. Return converted list as a string.
(fn LIST &optional PARAMS)
(defalias 'org-list-to-texinfo #[513 "\300\301!\210\302\303\304\"\"\207" [require ox-texinfo org-list-to-generic org-combine-plists (:backend texinfo)] 7 (#$ . 92060)])
#@193 Convert LIST into an Org plain list.
LIST is as returned by `org-list-parse-list'. PARAMS is a property list
with overruling parameters for `org-list-to-generic'.
(fn LIST &optional PARAMS)
(defalias 'org-list-to-org #[513 "\300\301\302\303\304\305\306\307\310\311\312\313\314\257\315\316\"\"\207" [#[770 "\300=\203\n \301\202 \302\205 \303\304\"P\207" [ordered "1. " "- " format "[@%d] "] 7 "\n\n(fn TYPE DEPTH &optional C)"] :istart :icount :ifmt #[514 "\300\301\302#\207" [replace-regexp-in-string "\n" "\n "] 6 "\n\n(fn TYPE CONTENTS)"] :dtend " :: " :cbon "[X] " :cboff "[ ] " :cbtrans "[-] " org-list-to-generic org-combine-plists] 17 (#$ . 92480)])
#@249 Convert LIST into an Org subtree.
LIST is as returned by `org-list-to-lisp'. Subtree starts at
START-LEVEL or level 1 if nil. PARAMS is a property list with
overruling parameters for `org-list-to-generic'.
(fn LIST &optional START-LEVEL PARAMS)
(defalias 'org-list-to-subtree #[769 "\305\236A\211\306\267\202$ \307\202% \212\307\310 \211\311\nP \312 \210,\313 )\202% \314\262\206, \315\316\317\320\321\322!\323\"\324\325%\326\327\330\307\331\332\333\334\335\334\336\203R \337\202S \340\341\342\343\344\345\344\257\"\"\207" [org-blank-before-new-entry org-called-with-limited-levels org-outline-regexp outline-regexp org-outline-regexp-bol heading #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (t 10 auto 14)) t org-get-limited-outline-regexp "^" outline-previous-heading org-previous-line-empty-p nil 1 make-byte-code 770 "\300S\\\302 \203 \303_S\202 \304\"\305P\207" vconcat vector [org-odd-levels-only make-string 2 42 " "] 7 "\n\n(fn TYPE DEPTH &optional COUNT)" org-list-to-generic org-combine-plists :splice :istart :icount :dtstart " " :dtend :isep "\n\n" "\n" :cbon "DONE " :cboff "TODO " :cbtrans] 28 (#$ . 93159)])
(provide 'org-list)
Mini Shell